public ProcessorSettings GetSettings()
{
var telegramSetting = new TelegramSettings {
Enabled = GetBool("TelegramEnabled"),
Token = GetString("TelegramBotToken"),
ChatId = GetString("TelegramChatId")
};
var elasticSearchClientSettings = new ElasticSearchClientSettings {
ComponentForIndex = ComponentType.ElasticSearch,
ElasticSearchUrl = GetString("ElasticSearchClientUrl"),
DefaultIndex = GetString("ElasticSearchClientIndex"),
FrameSize = GetInt("ElasticSearchClientFrameSize"),
ShopName = GetString("ElasticSearchClientShopName")
};
var settings = new ProcessorSettings {
AttemptsToDownload = GetInt("AttemptsToDownload"),
EnableExtendedStatistics = GetBool("EnableExtendedStatistics"),
DirectoryPath = GetString("DirectoryPath"),
DuplicateFile = GetString("DuplicateFile"),
ShowStatistics = GetBool("ShowStatistics"),
ElasticSearchClientSettings = elasticSearchClientSettings,
TelegramSettings = telegramSetting
};
return(settings);
}
public TelegramService(IDatabase database, TelegramSettings settings, IMemoryCache cache, IDatabaseConnector <TelegramDatabaseCredentials> databaseConnector)
{
_database = database;
_settings = settings;
_cache = cache;
_databaseConnector = databaseConnector;
}
private void MapTelegramSettings()
{
TelegramSettings telegramSettings = new TelegramSettings();
Configuration.GetSection(nameof(TelegramSettings)).Bind(telegramSettings);
AppSettingsProvider.TelegramSettings = telegramSettings;
}
public TelegramService(TelegramSettings settings,
IEnumerable <ITelegramSubscriber> subscribers, ILogFactory logFactory)
{
_settings = settings;
_subscribers = subscribers;
_log = logFactory.CreateLog(this);
}
public GetSettingsController(Microsoft.Extensions.Options.IOptionsMonitor <TelegramSettings> telegramSettings,
Services services)
{
_services = services;
_telegramService = services.TelegramService;
_telegramSettings = telegramSettings.CurrentValue;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
TelegramSettings ts = new TelegramSettings();
ts.Show();
ts.Closed += Ts_Closed;
}
public TelegramApiRequest(
IOptions <TelegramSettings> telegramConfig,
ILogger <TelegramApiRequest> logger)
{
_telegramConfig = telegramConfig.Value;
_logger = logger;
}
public ValidationFailure Test(TelegramSettings settings)
{
try
{
const string title = "Test Notification";
const string body = "This is a test message from Sonarr";
SendNotification(title, body, settings);
}
catch (Exception ex)
{
_logger.Error(ex, "Unable to send test message: " + ex.Message);
var restException = ex as RestException;
if (restException != null && restException.Response.StatusCode == HttpStatusCode.BadRequest)
{
var error = Json.Deserialize<TelegramError>(restException.Response.Content);
var property = error.Description.ContainsIgnoreCase("chat not found") ? "ChatId" : "BotToken";
return new ValidationFailure(property, error.Description);
}
return new ValidationFailure("BotToken", "Unable to send test message");
}
return null;
}
public TelegramAlertClient(
HttpClient httpClient,
IOptions <TelegramSettings> telegramSettings)
{
_logger = Log.ForContext("SourceContext", nameof(TelegramAlertClient));
_httpClient = httpClient;
_telegramSettings = telegramSettings.Value;
}
public TelegramController(
ITelegramBotClient telegramBot,
TelegramSettings telegramSettings
)
{
_telegramBot = telegramBot;
_chatId = telegramSettings.ChatId;
}
public TelegramRequest(
ILoggerFactory loggerFactory,
IReceiver fileReciever,
TelegramSettings telegramConfig)
// IOptions<TelegramSettings> telegramConfig)
{
_loggerFactory = loggerFactory;
_receiver = fileReciever;
_telegramConfig = telegramConfig;
}
public Telegram(IClientSettings settings)
{
if (settings is TelegramSettings telegramSettings)
{
_settings = telegramSettings;
}
else
{
throw new ArgumentException("Wrong settings type for telegram");
}
}
private static TelegramBotClient CreateClientWithProxy(TelegramSettings tgSettings, Socks5Settings socks5Settings)
{
var proxy = new HttpToSocks5Proxy(socks5Settings.Host, socks5Settings.Port, socks5Settings.Username, socks5Settings.Password);
proxy.ResolveHostnamesLocally = true;
var handler = new HttpClientHandler();
handler.Proxy = proxy;
handler.UseProxy = true;
var client = new HttpClient(handler);
return(new TelegramBotClient(tgSettings.BotApiKey, client));
}
private void SetSettingsSettings(TelegramSettings newSettings, bool save)
{
var state = _settings.States.FirstOrDefault(x => x.NationalNumber == NationalNumber);
if (state == null)
{
return;
}
state.Settings = newSettings;
if (save)
{
SaveSettings();
}
}
public void SendNotification(string title, string message, TelegramSettings settings)
{
//Format text to add the title before and bold using markdown
var text = $"*{title}*\n{message}";
var client = RestClientFactory.BuildClient(URL);
var request = new RestRequest("bot{token}/sendmessage", Method.POST);
request.AddUrlSegment("token", settings.BotToken);
request.AddParameter("chat_id", settings.ChatId);
request.AddParameter("parse_mode", "Markdown");
request.AddParameter("text", text);
client.ExecuteAndValidate(request);
}
public async Task <bool> Telegram([FromBody] TelegramSettings settings)
{
try
{
settings.Enabled = true;
await TelegramNotification.NotifyAsync(new NotificationOptions { NotificationType = NotificationType.Test, RequestId = -1 }, settings);
return(true);
}
catch (Exception e)
{
Log.LogError(LoggingEvents.Api, e, "Could not test Telegram");
return(false);
}
}
public static IServiceCollection AddConfigurations(this IServiceCollection services, IConfiguration configuration)
{
dataStoreSettings = new DataStoreSettings();
telegramSettings = new TelegramSettings();
loggingSettings = new NuciLoggerSettings();
configuration.Bind(nameof(DataStoreSettings), dataStoreSettings);
configuration.Bind(nameof(TelegramSettings), telegramSettings);
configuration.Bind(nameof(NuciLoggerSettings), loggingSettings);
services.AddSingleton(dataStoreSettings);
services.AddSingleton(telegramSettings);
services.AddSingleton(loggingSettings);
return(services);
}
public override async Task Run(object prm)
{
if (IsRunning || _me != null)
{
return;
}
IsRunning = true;
try
{
Settings = TelegramSettings.Load(SettingsManager.FileSettingsPath);
if (Settings.TelegramModule == null || string.IsNullOrEmpty(Settings.TelegramModule.Token))
{
await LogHelper.LogError("Token is not set for Telegram module!", Category);
return;
}
if (Settings.TelegramModule.RelayChannels.Count == 0 || Settings.TelegramModule.RelayChannels.All(a => a.Telegram == 0) ||
Settings.TelegramModule.RelayChannels.All(a => a.Discord == 0))
{
await LogHelper.LogError("No relay channels set for Telegram module!", Category);
return;
}
_client = new TelegramBotClient(Settings.TelegramModule.Token);
_client.OnMessage += BotClient_OnMessage;
if (!await _client.TestApiAsync())
{
await LogHelper.LogError("API ERROR!", Category);
return;
}
_client.OnReceiveError += _client_OnReceiveError;
_client.OnReceiveGeneralError += _client_OnReceiveGeneralError;
_me = await _client.GetMeAsync();
_client.StartReceiving();
await LogHelper.LogInfo("Telegram bot connected!", Category);
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
}
finally
{
IsRunning = false;
}
}
private void ReadTelegramSettings()
{
var settingsPath = Path.Combine(Directory.GetCurrentDirectory(), TlgrmFilePath);
if (File.Exists(settingsPath))
{
var jsonSettings = new JsonSerializerSettings();
jsonSettings.Converters.Add(new StringEnumConverter {
CamelCaseText = true
});
jsonSettings.ObjectCreationHandling = ObjectCreationHandling.Replace;
jsonSettings.DefaultValueHandling = DefaultValueHandling.Populate;
_tlgrmSettings = SerializeUtils.DeserializeDataJson <TelegramSettings>(settingsPath) ?? new TelegramSettings();
return;
}
_tlgrmSettings = new TelegramSettings();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
if (environment.IsDevelopment())
{
appConfiguration = new AppConfiguration(new TelegramSettings(), new SoundCloudSettings());
configurationRoot.Bind(appConfiguration);
services.AddSingleton <IAppConfiguration>(appConfiguration);
}
else if (environment.IsProduction())
{
var envDictionary = new Dictionary <string, string>();
foreach (var item in Environment.GetEnvironmentVariables())
{
var entry = item is DictionaryEntry dictionaryEntry ? dictionaryEntry : default;
envDictionary[entry.Key.ToString()] = entry.Value.ToString();
}
var soundCloudSettings = new SoundCloudSettings
{
ClientId = envDictionary[nameof(SoundCloudSettings.ClientId).ToUpper()]
};
var telegramSettings = new TelegramSettings
{
BotToken = envDictionary[nameof(TelegramSettings.BotToken).ToUpper()]
};
var appConfig = new AppConfiguration(telegramSettings, soundCloudSettings)
{
WebhookUrl = "https://soundcloud-in-play-tg-bot.herokuapp.com",
AllowedUpdates = configurationRoot.GetSection(nameof(AppConfiguration.AllowedUpdates)).Get <UpdateType[]>()
};
services.AddSingleton <IAppConfiguration>(appConfig);
}
services.AddControllers().AddNewtonsoftJson();
//services.AddSingleton<IAppConfiguration>(appConfiguration);
services.AddSingleton <IBotProvider, BotProvider>();
services.AddHostedService <BotInitializerHostedService>();
services.AddScoped <ICurrentMessageProvider, CurrentMessageProvider>();
services.AddHttpClient();
services.AddTelegramCommands();
services.AddSoundCloudServices();
services.AddCaches();
}
//public Session Session
//{
// get { return this.session; }
//}
/// <summary>
/// Ctor
/// </summary>
/// <param name="authModel">Telegram authenthication model</param>
/// <param name="settings">Telegram settings for client</param>
public TelegramClient(
TelegramSettings settings = null)
{
settings ??= new TelegramSettings();
settings.SessionStore ??= new FileSessionStore();
settings.SessionId ??= "session";
//settings.Handler ??= null;
//settings.DcIpVersion = DataCenterIPVersion.Default;
//this.apiHash = apiHash;
//this.apiId = apiId;
//this.handler = handler;
//this.dcIpVersion = dcIpVersion;
this._session = TelegramSession.TryLoadOrCreateNew(settings.SessionStore, settings.SessionId);
this.transport = new TcpTransport(
this._session.DataCenter.Address,
this._session.DataCenter.Port,
this.handler);
}
public void Load()
{
var fileSource = LoadFromFile();
var json = JToken.Parse(fileSource);
Bittrex = new BittrexSettings
{
Key = json["bittrex"]["key"].ToObject <string>(),
Secret = json["bittrex"]["secret"].ToObject <string>(),
Market = json["bittrex"]["market"].ToObject <string>(),
RiskManager = new BittrexRiskManagerSettings
{
BaseCurrency = json["bittrex"]["riskManager"]["baseCurrency"].ToObject <string>(),
Type = json["bittrex"]["riskManager"]["type"].ToObject <string>() == "percent" ?
RiskManagerBalanceType.Percent : RiskManagerBalanceType.Fixed,
Percent = json["bittrex"]["riskManager"]["percent"].ToObject <int>(),
Amount = json["bittrex"]["riskManager"]["amount"].ToObject <decimal>(),
BalanceMinLimit = json["bittrex"]["riskManager"]["balanceMinLimit"].ToObject <decimal>()
}
};
Db = new MongoDbSettings
{
DbConnectoin = json["database"]["connectionString"].ToObject <string>(),
DbName = json["database"]["dataBaseName"].ToObject <string>()
};
RabbitMQ = new RabbitMqSettings
{
Host = new Uri(json["rabbitMq"]["host"].ToObject <string>()),
ConcurrencyLimit = json["rabbitMq"]["concurrencyLimit"].ToObject <int>()
};
Telegram = new TelegramSettings
{
ApiKey = json["telegram"]["apiKey"].ToObject <int>(),
ApiHash = json["telegram"]["apiHash"].ToObject <string>(),
PhoneNumber = json["telegram"]["phoneNumber"].ToObject <string>(),
Enabled = json["telegram"]["enabled"].ToObject <bool>()
};
}
public TelegramBot(Settings settings, XabeConverter xabeConverter)
{
_settings = settings.Telegram;
_videoСonverter = xabeConverter;
//_voiceСonverter = new VoskAudioRecognizer();
Console.WriteLine("Starting Telegram Bot");
var cts = new CancellationTokenSource();
var cancellationToken = cts.Token;
var receiverOptions = new ReceiverOptions
{
AllowedUpdates = { } // receive all update types
};
_client = new TelegramBotClient(_settings.Token);
_client.StartReceiving(HandleUpdateAsync, HandleErrorAsync, receiverOptions, cancellationToken);
var(id, name) = GetBotInfoAsync().Result;
Console.WriteLine($"Telegram Bot init successfully. ID: {id} | Name: {name}");
}
private static void Save(Service service, uint accountId, TelegramSettings settings)
{
try
{
settings.AccountId = accountId;
SettingsManager.Save(service, settings);
if (ServiceManager.IsRunning(service))
{
Utils.DebugPrint("Service is running. Aborting....");
ServiceManager.Abort(service).Wait();
}
Utils.DebugPrint("Starting the service...!");
ServiceManager.Start(service, true);
}
catch (Exception ex)
{
Utils.DebugPrint("Failed to save the Telegram service: " + ex);
}
MutableSettingsManager.Delete <TelegramSetupSettings>();
}
private static void Save(Service service, uint accountId, TelegramSettings settings)
{
try
{
settings.AccountId = accountId;
SettingsManager.Save(service, settings);
if (ServiceManager.IsRunning(service))
{
Utils.DebugPrint("Service is running. Aborting....");
ServiceManager.Abort(service).Wait();
}
Utils.DebugPrint("Starting the service...!");
ServiceManager.Start(service, true);
}
catch (Exception ex)
{
Utils.DebugPrint("Failed to save the Telegram service: " + ex);
}
MutableSettingsManager.Delete<TelegramSetupSettings>();
}
public Info(Service service, TabbedPage tabs, Verify verify)
{
_phoneNumberContainer = new StackLayout();
_phoneNumberContainer.Orientation = StackOrientation.Horizontal;
_phoneNumberContainer.HorizontalOptions = LayoutOptions.FillAndExpand;
_phoneNumber = new PhoneEntry();
_phoneNumber.Placeholder = Localize.GetString("TelegramPhoneNumber");
_phoneNumber.HorizontalOptions = LayoutOptions.FillAndExpand;
_phoneNumberContainer.Children.Add(_phoneNumber);
var programmaticChange = false;
_firstName = new Entry();
_firstName.Placeholder = Localize.GetString("TelegramFirstName");
_lastName = new Entry();
_lastName.Placeholder = Localize.GetString("TelegramLastName");
_loadConversations = new CheckBox();
_loadConversations.DefaultText = Localize.GetString("TelegramLoadConversations");
_loadConversations.CheckedChanged += (sender, e) =>
{
//TODO:
};
_loadConversations.Checked = true;
_next = new Button();
_next.HorizontalOptions = LayoutOptions.FillAndExpand;
_next.Text = Localize.GetString("TelegramNext");
_next.TextColor = Color.White;
_next.BackgroundColor = Color.FromHex("77D065");
_next.Clicked += async(sender, e) =>
{
if (String.IsNullOrWhiteSpace(_firstName.Text))
{
await DisplayAlert(Localize.GetString("TelegramInvalidFirstNameTitle"), Localize.GetString("TelegramInvalidFirstNameMessage"), Localize.GetString("TelegramOkay"));
return;
}
if (String.IsNullOrWhiteSpace(_lastName.Text))
{
await DisplayAlert(Localize.GetString("TelegramInvalidLastNameTitle"), Localize.GetString("TelegramInvalidLastNameMessage"), Localize.GetString("TelegramOkay"));
return;
}
Func <Task> invalidNumber = () =>
{
return(DisplayAlert(Localize.GetString("TelegramInvalidNumberTitle"),
Localize.GetString("TelegramInvalidNumberMessage"), Localize.GetString("TelegramOkay")));
};
if (!PhoneBook.IsPossibleNumber(_phoneNumber.Text))
{
await invalidNumber();
return;
}
var number = PhoneBook.TryGetPhoneNumberLegible(_phoneNumber.Text);
var formattedNumber = PhoneBook.FormatPhoneNumber(number);
if (formattedNumber == null)
{
await invalidNumber();
return;
}
var nationalNumber = new string(formattedNumber.Item2.Where(Char.IsDigit).ToArray());
if (!await DisplayAlert(Localize.GetString("TelegramConfirmNumberTitle"),
Localize.GetString("TelegramConfirmNumberMessage").Replace("[number]", number),
Localize.GetString("TelegramYes"),
Localize.GetString("TelegramNo")))
{
return;
}
_progressBar.IsVisible = true;
_next.IsEnabled = false;
_firstName.IsEnabled = false;
_lastName.IsEnabled = false;
_phoneNumber.IsEnabled = false;
DependencyService.Get <IPluginPageControls>().BackPressEnabled = false;
TelegramSettings settings = null;
var skipSave = false;
var state = _settings.States.FirstOrDefault(x => x.NationalNumber == nationalNumber);
if (state != null && state.Settings != null)
{
skipSave = true;
settings = state.Settings;
}
else
{
settings = await Task <TelegramSettings> .Factory.StartNew(() => { return(Telegram.GenerateAuthentication(service)); });
}
var firstName = _firstName.Text.Trim();
var lastName = _lastName.Text.Trim();
DependencyService.Get <IPluginPageControls>().BackPressEnabled = true;
_firstName.IsEnabled = true;
_lastName.IsEnabled = true;
_phoneNumber.IsEnabled = true;
_next.IsEnabled = true;
_progressBar.IsVisible = false;
if (settings == null)
{
await DisplayAlert(Localize.GetString("TelegramAuthGenerationFailedTitle"),
Localize.GetString("TelegramAuthGenerationFailedMessage"), Localize.GetString("TelegramOkay"));
return;
}
if (!skipSave)
{
_settings.States.Add(new Setup.TelegramSetupSettings.State
{
Settings = settings,
NationalNumber = nationalNumber
});
SaveSettings();
}
verify.CountryCode = formattedNumber.Item1;
verify.NationalNumber = nationalNumber;
verify.FirstName = firstName;
verify.LastName = lastName;
tabs.Children.Add(verify);
tabs.CurrentPage = verify;
};
_image = new Image();
_image.Source = ImageSource.FromUri(
new Uri("https://lh4.ggpht.com/fuvTtxbZ1-dkEmzUMfKcgMJwW8PyY4fhJJ_NKT-NpIQJukszEY2GfCkJUF5ch6Co3w=w300"));
_image.WidthRequest = 100;
_image.HeightRequest = 100;
_progressBar = new ActivityIndicator();
_progressBar.VerticalOptions = LayoutOptions.EndAndExpand;
_progressBar.IsRunning = true;
_progressBar.IsVisible = false;
var stackLayout = new StackLayout();
stackLayout.Spacing = 20;
stackLayout.Padding = 25;
stackLayout.VerticalOptions = LayoutOptions.Start;
var children = stackLayout.Children;
children.Add(_image);
children.Add(_firstName);
children.Add(_lastName);
children.Add(_phoneNumberContainer);
children.Add(_loadConversations);
var nextLayout = new StackLayout();
nextLayout.Spacing = 20;
nextLayout.Orientation = StackOrientation.Horizontal;
nextLayout.Children.Add(_next);
nextLayout.Children.Add(_progressBar);
children.Add(nextLayout);
Content = new ScrollView {
Content = stackLayout
};
Title = Localize.GetString("TelegramInformationTitle");
}
private static TelegramBotClient CreateClientWithoutProxy(TelegramSettings settings) => new TelegramBotClient(settings.BotApiKey);
public TelegramChannel(IOptionsMonitor <TelegramSettings> rulesAccessor, ILogger logger) : base(logger)
{
telegramSettings = rulesAccessor.CurrentValue;
}
public TelegramNotificationSender(TelegramSettings telegramSettings)
{
this.telegramSettings = telegramSettings;
botClient = new TelegramBotClient(telegramSettings.AccessToken);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddDbContextPool <DataContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("DefaultConnection"), x =>
x.SuppressForeignKeyEnforcement())
);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddMemoryCache();
// Setting Telegram
var telegramConfig = new TelegramSettings();
Configuration.Bind("TelegramSettings", telegramConfig);
services.AddSingleton(telegramConfig);
services.AddScoped <ITelegramRequest, TelegramRequest>();
//services.Configure<TelegramSettings>(Configuration.GetSection("TelegramSettings");
services.Configure <FilePaths>(Configuration.GetSection("FilePaths"));
services.AddSingleton <IReceiver, FileReceiver>();
services.AddSingleton(typeof(IMyLogger <>), typeof(MyLogger <>));
services.AddScoped <IDataRepository, DataRepository>();
services.AddScoped <IAuthRepository, AuthRepository>();
services.AddScoped <IBackwardRepository, IBackwardRepository>();
// Setting BD
services.AddScoped <ITelegramView, TelegramView>();
services.AddSingleton(provider => new MapperConfiguration(cfg => {
var scope = provider.GetRequiredService <IServiceScopeFactory>().CreateScope();
var context = scope.ServiceProvider.GetService <DataContext>();
cfg.AddProfile(new AutoMapperProfiles(context));
}).CreateMapper());
//services.AddAutoMapper(typeof(Startup));
// Messages
services.AddScoped <DataChecker>();
services.AddScoped <MainMenuChecker>();
//services.AddScoped<SimpleCommandChecker>();
services.AddScoped <IMessageChecker>(provider => {
var _messageChecker = (IMessageChecker)provider.GetService <DataChecker>();
_messageChecker
.SetNext(provider.GetService <MainMenuChecker>());
//.SetNext(provider.GetService<SimpleCommandChecker>());
return(_messageChecker);
});
services.AddScoped <DataCallbackChecker>();
services.AddScoped <SettingsChecker>();
services.AddScoped <CategoryCallbackChecker>();
services.AddScoped <ICallbackChecker>(provider => {
var _callbackChecker = (ICallbackChecker)provider.GetService <DataCallbackChecker>();
_callbackChecker
.SetNext(provider.GetService <SettingsChecker>())
.SetNext(provider.GetService <CategoryCallbackChecker>());
return(_callbackChecker);
});
services.AddTransient <Seed>();
}
public TelegramService(TelegramSettings settings, ILogFactory logFactory)
{
_settings = settings;
_log = logFactory.CreateLog(this);
}
private void SetSettingsSettings(TelegramSettings newSettings, bool save)
{
var state = _settings.States.FirstOrDefault(x => x.NationalNumber == NationalNumber);
if (state == null)
return;
state.Settings = newSettings;
if (save)
{
SaveSettings();
}
}
public static void RegisterCredentials(ContainerBuilder builder)
{
builder.Register(b =>
{
var configuration = b.Resolve <IConfiguration>();
var credentials = new HangfireDatabaseCredentials();
credentials.BuildConnectionString(
configuration["Hangfire:Sql:Url"],
configuration["Hangfire:Sql:Port"].To <int>(),
configuration["Hangfire:Sql:Catalog"],
configuration["Hangfire:Sql:User"],
configuration["Hangfire:Sql:Password"]);
return(credentials);
}).SingleInstance();
builder.Register(b =>
{
var configuration = b.Resolve <IConfiguration>();
var credentails = new IdentityModelCredentials()
{
ClientId = configuration["Auth:Client:Id"],
ClientSecret = configuration["Auth:Client:Secret"]
};
return(credentails);
}).SingleInstance();
builder.Register(b =>
{
var configuration = b.Resolve <IConfiguration>();
var credentails = new RedisCredentials();
credentails.BuildConnectionString(
configuration["Redis:Name"],
configuration["Redis:Password"],
configuration["Redis:Port"].To <int>(),
isSsl: true,
allowAdmin: true);
return(ConnectionMultiplexer.Connect(credentails.ConnectionString));
}).SingleInstance();
builder.Register(b =>
{
var configuration = b.Resolve <IConfiguration>();
var credentials = new TelegramDatabaseCredentials();
credentials.BuildConnectionString(
configuration["Api:Sql:Url"],
configuration["Api:Sql:Port"].To <int>(),
configuration["Api:Sql:Catalog"],
configuration["Api:Sql:User"],
configuration["Api:Sql:Password"]);
return(credentials);
}).SingleInstance();
builder.Register(b =>
{
var configuration = b.Resolve <IConfiguration>();
var settings = new TelegramSettings()
{
AppHash = configuration["Telegram:Settings:AppHash"],
AppId = configuration["Telegram:Settings:AppId"].To <int>(),
ServerAddress = configuration["Telegram:Settings:ServerAddress"],
ServerPort = configuration["Telegram:Settings:ServerPort"].To <int>(),
ServerPublicKey = configuration["Telegram:Settings:ServerPublicKey"]
};
return(settings);
}).SingleInstance();
builder.Register(b =>
{
var configuration = b.Resolve <IConfiguration>();
var connectionStringBuilder = new EventHubsConnectionStringBuilder(configuration["EventHub:ConnectionString"])
{
EntityPath = configuration["EventHub:EntityPath"]
};
return(connectionStringBuilder);
}).SingleInstance();
}
