public MessagerService(IOptions <SmtpOptions> smtpOptions, IOptions <SmsOptions> smsOptions, IHttpClientFactory clientFactory, IUnitOfWork unitOfWork)
{
this.smtpOptions = smtpOptions.Value;
this.smsOptions = smsOptions.Value;
this.clientFactory = clientFactory;
this.unitOfWork = unitOfWork;
}
public PassportClient(AppSettings appSettings, IRedisCache redisCache, HttpClient httpClient, IAuthorizeTokenClient authorizeTokenClient, SmsOptions smsServerOptions) : base(httpClient)
{
_appSettings = appSettings;
_redisCache = redisCache;
_authorizeTokenClient = authorizeTokenClient;
_smsServerOptions = smsServerOptions;
}
public IndexModel(ISmsService smsService, ICitizenService citizenService, ICitizenNotifier citizenNotifier, SmsOptions smsOptions, IAudit audit)
{
_smsService = smsService;
_smsOptions = smsOptions;
_audit = audit;
_citizenService = citizenService;
_citizenNotifier = citizenNotifier;
}
public static SmsOptions UseAliyun(this SmsOptions options, Action <AliyunSmsOptions> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
options.RegisterExtension(new AliyunOptionsExtension(configure));
return(options);
}
public static SmsOptions UseChinaMobile(this SmsOptions options, Action <ChinaMobileSmsOptions> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
options.RegisterExtension(new ChinaMobileSmsOptionsExtension(configure));
return(options);
}
/// <summary>
///
/// </summary>
public ValidationComponent(IRedisCache redisCache,
IOptions <SmsOptions> smsOptions, IPassportClient passportClient, ISmsRecordRepository smsRecordRepository, IUnitOfWork unitOfWork, IBackgroundRunService backgroundRunService, AppSettings appSettings)
{
_redisCache = redisCache;
_passportClient = passportClient;
_smsRecordRepository = smsRecordRepository;
_unitOfWork = unitOfWork;
_backgroundRunService = backgroundRunService;
_appSettings = appSettings;
_smsServerOptions = smsOptions.Value;
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (EmailOptions != null ? EmailOptions.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (SmsOptions != null ? SmsOptions.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (PublicKey != null ? PublicKey.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (PrivateKey != null ? PrivateKey.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Token != null ? Token.GetHashCode() : 0);
return(hashCode);
}
}
public MemberSMSValiCodeTaskAPIController(ICommunityService communityService
, MemberDbContext memberDb
, ISmsHandler smsHandler
, IOptions <MemberAPIOptions> options
, IOptions <SmsOptions> smsOptions
, ILoggerFactory loggerFactory)
: base(communityService, options, memberDb)
{
this.smsHandler = smsHandler;
this.smsOptions = smsOptions.Value;
_logger = loggerFactory.CreateLogger <MemberAPIController>();
}
public ManageController(UserManager <TUser> userManager, SignInManager <TUser> signInManager,
IEmailSender emailSender, ILogger <ManageController <TUser, TKey> > logger,
IGenericControllerLocalizer <ManageController <TUser, TKey> > localizer, UrlEncoder urlEncoder,
ISmsSender smsSender, IOptions <SmsOptions> smsOptions, IOptions <AvatarOptions> avatarOptions)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_localizer = localizer;
_urlEncoder = urlEncoder;
_smsSender = smsSender;
_smsOptions = smsOptions.Value;
_avatarOptions = avatarOptions.Value;
}
private static async Task <int> Sms(SmsOptions opts)
{
if (!ValidateSmsArguments(opts))
{
return(255);
}
var api = new LogicApi();
var smsId = await api.SendSmsAsync(opts.PhoneNumber, opts.Body).ConfigureAwait(false);
Console.WriteLine($"Message sent, SmsMessageId = {smsId}");
return(0);
}
public static void AddInfra(this IServiceCollection services, IConfiguration config)
{
var redisOptions = ConfigurationOptions.Parse(config.GetConnectionString("redis"));
services.AddSingleton(redisOptions);
services.AddSingleton <IConnectionMultiplexer>(ConnectionMultiplexer.Connect(redisOptions));
services.AddSignalR().AddStackExchangeRedis(config.GetConnectionString("redis"));
var jsonOptions = new JsonSerializerOptions
{
AllowTrailingCommas = false,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault,
ReadCommentHandling = JsonCommentHandling.Skip
};
jsonOptions.Converters.Add(new OpenIdKeyConverter());
jsonOptions.Converters.Add(new StatusConverter());
jsonOptions.Converters.Add(new BloodGroupConverter());
services.AddSingleton(jsonOptions);
var smtpOptions = new SmtpOptions();
var smsOptions = new SmsOptions();
config.Bind("smtp", smtpOptions);
config.Bind("sms", smsOptions);
services.AddSingleton(smtpOptions);
services.AddSingleton(smsOptions);
NReJSONSerializer.SerializerProxy = new ReJsonSerializerProxy(jsonOptions);
services.AddHostedService <NewRequestProcessingService>();
// Singleton: creates a new instance only once during the application lifetime
// Scoped: creates a new instance for every request
// Transient: creates a new instance every time you request it
services.AddScoped <ICurrentUser, CurrentUser>();
services.AddSingleton <IMessaging, Messaging>();
services.AddTransient <IUserRepository, UserRepository>();
services.AddTransient <IBloodRequestRepository, BloodRequestRepository>();
services.AddTransient <IBloodRequestsSearchRepository, BloodRequestsSearchRepository>();
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="wechatOptions"></param>
/// <param name="smsOptions"></param>
/// <param name="smsHandler"></param>
/// <param name="wechatCoreDb"></param>
/// <param name="communityService"></param>
/// <param name="memberOptions"></param>
/// <param name="memberDb"></param>
/// <param name="loggerFactory"></param>
public WechatAPIController(
IOptions <WechatOptions> wechatOptions,
IOptions <SmsOptions> smsOptions,
ISmsHandler smsHandler,
WechatCoreDbContext wechatCoreDb,
ICommunityService communityService,
IOptions <MemberAPIOptions> memberOptions,
MemberDbContext memberDb,
ILoggerFactory loggerFactory)
: base(memberOptions, memberDb, wechatCoreDb)
{
this.smsHandler = smsHandler;
this.smsOptions = smsOptions.Value;
this.wechatOptions = wechatOptions.Value;
_logger = loggerFactory.CreateLogger <WechatAPIController>();
}
static bool ValidateSmsArguments(SmsOptions opts)
{
if (!IsPhoneValid(opts.PhoneNumber))
{
Console.WriteLine("Invalid phone number");
}
if (string.IsNullOrWhiteSpace(opts.Body))
{
Console.WriteLine("Body is required");
}
if (opts.Body.Length > 160)
{
Console.WriteLine("Body cannot be longer than 160 characters");
}
return(true);
}
public static IServiceCollection AddSms(this IServiceCollection services, Action <SmsOptions> setupAction = null)
{
if (services.Any(x => x.ServiceType == typeof(SmsOptions)))
{
throw new InvalidOperationException("SMS services already registered");
}
ServiceCollection = services;
//Inject Services
//Options and extension service
var options = new SmsOptions();
setupAction?.Invoke(options);
foreach (var serviceExtension in options.Extensions)
{
serviceExtension.AddServices(services);
}
services.Configure <SmsOptions>(setupAction);
return(services);
}
public SmsSender(IOptions <SmsOptions> smsOptions)
{
_smsOptions = smsOptions.Value;
}
public LogicSmsService(SmsClient smsClient, SmsOptions smsOptions)
{
_smsClient = smsClient;
_smsOptions = smsOptions;
}
public SmsSender(IOptionsMonitor <SmsOptions> optionsAccessor)
{
_options = optionsAccessor.CurrentValue;
_singleSender = new SmsSingleSender(_options.AppId, _options.AppKey);
}
public SmsDto()
{
Phones = new List <string>();
Message = "";
Options = new SmsOptions();
}
public SmsDto(IEnumerable <string> phones, string message, SmsOptions options)
{
Phones.AddRange(phones);
Message = message;
Options = options;
}
public RichSmsSender(ILogger <RichSmsSender> logger, IOptions <SmsOptions> options, IRichProxy richProxy)
{
_logger = logger;
_options = options.Value;
_richProxy = richProxy;
}
public WFwSmsClient(SmsOptions op, ILogger <WFwSmsClient> l)
{
options = op;
client = new SmsClient(options.GetCredential(), options.Regin);
logger = l;
}
public SmsService(IOptions <SmsOptions> options)
{
this.options = options.Value;
}
public Messaging(SmsOptions smsOptions, SmtpOptions smtpOptions, ILogger <Messaging> logger)
{
_smsOptions = smsOptions;
_smtpOptions = smtpOptions;
_logger = logger;
}
public SmsDto(string phone, string message, SmsOptions options)
{
Phones.Add(phone);
Message = message;
Options = options;
}
public static IServiceCollection AddSmsNotification(this IServiceCollection services, SmsOptions options)
{
if (options.UsedFake())
{
services.AddFakeSmsNotification();
}
else if (options.UsedTwilio())
{
services.AddTwilioSmsNotification(options.Twilio);
}
else if (options.UsedAzure())
{
services.AddAzureSmsNotification(options.Azure);
}
return(services);
}
private static bool IsValid(SmsOptions options)
{
return(!string.IsNullOrEmpty(options.ApiKey));
}
