private Response SaveSlackNotifications()
{
var settings = this.BindAndValidate <SlackNotificationSettings>();
if (!ModelValidationResult.IsValid)
{
return(Response.AsJson(ModelValidationResult.SendJsonError()));
}
var result = SlackSettings.SaveSettings(settings);
if (settings.Enabled)
{
NotificationService.Subscribe(new SlackNotification(SlackApi, SlackSettings));
}
else
{
NotificationService.UnSubscribe(new SlackNotification(SlackApi, SlackSettings));
}
Log.Info("Saved slack settings, result: {0}", result);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true, Message = "Successfully Updated the Settings for Slack Notifications!"
}
: new JsonResponseModel {
Result = false, Message = "Could not update the settings, take a look at the logs."
}));
}
public SlackSettings BuildSlackSettings()
{
var slackSettings = new SlackSettings();
try
{
slackSettings = _configuration.GetSection("Slack").Get <SlackSettings>();
}
catch { }
if (string.IsNullOrWhiteSpace(slackSettings.SlackWebhookUrl))
{
slackSettings = new SlackSettings
{
SlackWebhookUrl = Environment.GetEnvironmentVariable("SlackUrl"),
SlackWorkspaceUrl = Environment.GetEnvironmentVariable("SlackWorkspaceUrl"),
SlackChannelId = Environment.GetEnvironmentVariable("SlackChannelId"),
SlackBotUserAccessToken = Environment.GetEnvironmentVariable("SlackBotUserAccessToken"),
SlackClientId = Environment.GetEnvironmentVariable("SlackClientId"),
SlackClientSecret = Environment.GetEnvironmentVariable("SlackClientSecret"),
SlackRedirectUri = Environment.GetEnvironmentVariable("SlackRedirectUri")
};
}
return(slackSettings);
}
public void Constructor_WhenSettingsUrlInvalid_ThrowsException(string url)
{
var settings = new SlackSettings {
Url = url
};
var exception = Assert.Throws <ArgumentException>(() => new SlackNotifier(settings));
Assert.That(exception.ParamName, Is.EqualTo("settings"));
}
public static void InitSettings(string directory)
{
var builder = new ConfigurationBuilder()
.SetBasePath(directory)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfigurationRoot configuration = builder.Build();
_slackSettings = configuration.GetSection("SlackSettings").Get <SlackSettings>();
_philipsHueSettings = configuration.GetSection("PhilipsHueSettings").Get <PhilipsHueSettings>();
}
public SlackTransactionsIncrementPublisher(
ILogFactory logFactory,
TransactionsReportWriter writer,
SlackSettings settings)
{
_log = logFactory.CreateLog(this);
_writer = writer;
_settings = settings;
_client = new SlackTaskClient(settings.AuthToken);
}
public override void SetUp()
{
base.SetUp();
fakeSettings = new SlackSettings
{
DebounceTimeInSecs = 180,
Threshold = NotificationLevel.Error,
Url = "http://localhost/dummy/url",
};
}
public SlackNotifier(SlackSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (string.IsNullOrWhiteSpace(settings.Url))
{
throw new ArgumentException("settings.Url was not set", nameof(settings));
}
this.settings = settings;
}
public AskExpertsSlackActionHandlerTests()
{
var slackSettings = new SlackSettings {
ExpertsChannelId = "CBGJMA0TA"
};
var options = Options.Create(slackSettings);
_questionServiceMock = new Mock <IQuestionService>();
_slackClientMock = new Mock <ISlackHttpClient>();
var logger = new Mock <ILogger <AskExpertsSlackActionHandler> >();
_handler = new AskExpertsSlackActionHandler(_questionServiceMock.Object, _slackClientMock.Object, options,
logger.Object);
_slackClientMock
.Setup(m => m.SendMessageAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <List <AttachmentDto> >()))
.Returns(Task.CompletedTask);
}
public SrvSlackNotifications(SlackSettings settings, IMessagesRepository messagesRepository, AppSettings globalSettings)
{
_settings = settings;
_messagesRepository = messagesRepository;
if (!string.IsNullOrEmpty(_settings.Env))
{
_environment = $"Environment: {_settings.Env}";
}
var opsgenieHost = globalSettings.SlackNotificationsJobSettings.OpsgenieHost;
var opsgenieKey = globalSettings.SlackNotificationsJobSettings.OpsgenieApiKey;
_opsgenieClient = new HttpClient();
_opsgenieClient.DefaultRequestHeaders.Accept.Clear();
_opsgenieClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_opsgenieClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("GenieKey", opsgenieKey);
_opsgenieClient.BaseAddress = new Uri(opsgenieHost);
}
private void SaveSettings()
{
SlackSettings newSettings = new SlackSettings(_channelKey, _apiKey, _lastReadMessage, _botUserId, _botName);
using (Stream fileStream = File.OpenWrite(_settingsFileLocation))
{
StreamWriter writer = new StreamWriter(fileStream);
try
{
string json = JsonConvert.SerializeObject(newSettings, Formatting.Indented);
writer.Write(json);
writer.Dispose();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
private async Task <Response> TestSlackNotification()
{
var settings = this.BindAndValidate <SlackNotificationSettings>();
if (!ModelValidationResult.IsValid)
{
return(Response.AsJson(ModelValidationResult.SendJsonError()));
}
var notificationModel = new NotificationModel
{
NotificationType = NotificationType.Test,
DateTime = DateTime.Now
};
var currentSlackSettings = await SlackSettings.GetSettingsAsync();
try
{
NotificationService.Subscribe(new SlackNotification(SlackApi, SlackSettings));
settings.Enabled = true;
await NotificationService.Publish(notificationModel, settings);
Log.Info("Sent slack notification test");
}
catch (Exception e)
{
Log.Error(e, "Failed to subscribe and publish test Slack Notification");
}
finally
{
if (!currentSlackSettings.Enabled)
{
NotificationService.UnSubscribe(new SlackNotification(SlackApi, SlackSettings));
}
}
return(Response.AsJson(new JsonResponseModel {
Result = true, Message = "Successfully sent a test Slack Notification! If you do not receive it please check the logs."
}));
}
private void LoadSettings()
{
string test = Directory.GetCurrentDirectory();
using (Stream fileStream = File.OpenRead(_settingsFileLocation))
{
if (fileStream == null)
{
Console.WriteLine("Failed to load SlackVariables.json");
return;
}
try
{
StreamReader reader = new StreamReader(fileStream);
string json = reader.ReadToEnd();
if (string.IsNullOrWhiteSpace(json))
{
Console.WriteLine("SlackVariables.Json is empty");
return;
}
SlackSettings slackSettings = JsonConvert.DeserializeObject <SlackSettings>(json);
_apiKey = slackSettings.ApiKey;
_channelKey = slackSettings.ChannelKey;
_lastReadMessage = slackSettings.LastReadMessage;
_botUserId = slackSettings.BotUserId;
_botName = slackSettings.BotName;
reader.Dispose();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
private Negotiator SlackNotifications()
{
var settings = SlackSettings.GetSettings();
return(View["SlackNotifications", settings]);
}
public HomeController(StravaService stravaService, SlackSettings slackSettings)
{
_stravaService = stravaService;
_slackSettings = slackSettings;
}
public SlackController(SlackSettings slackSettings)
{
_slackSettings = slackSettings;
_client = new HttpClient();
}
public HomeController(IOptions <SlackSettings> slackSettings)
{
_slackSettings = slackSettings.Value;
}
