public SlackServiceTests(ITestOutputHelper output) : base(output)
{
_slackService = GetService <SlackService>();
_project = ProjectData.GenerateSampleProject();
_project.Data[Project.KnownDataKeys.SlackToken] = new SlackToken {
AccessToken = "MY KEY",
IncomingWebhook = new SlackToken.IncomingWebHook {
Url = "MY Url"
}
};
}
public PreferencesViewModel(IEventAggregator eventAggregator, IMessageBoxService msgBoxService, SlackService slackService)
{
EVENT_AGGREGATOR = eventAggregator;
EVENT_AGGREGATOR.Subscribe(this);
MSG_BOX_SERVICE = msgBoxService;
SLACK_SERVICE = slackService;
SLACK_SERVICE.OnBotConnectionChanged += OnSlackBotConnected;
SLACK_SERVICE.OnBotChannelChanged += OnSlackBotChannelChanged;
LoadPreferences();
}
public ActionResult ConnectSlack()
{
var siteSettings = _settingsService.GetSiteSettings();
var slackService = new SlackService(siteSettings.SlackSettings);
var urlHelper = new UrlHelper(ControllerContext.RequestContext);
var callbackUrl = urlHelper.Action("SlackCallback", "Profile", null, "http");
var redirect = slackService.Authorize(callbackUrl);
return(Redirect(redirect));
}
public EventNotificationsJob(IQueue <EventNotification> queue, SlackService slackService, IMailer mailer, IProjectRepository projectRepository, AppOptions appOptions, EmailOptions emailOptions, IUserRepository userRepository, IEventRepository eventRepository, ICacheClient cacheClient, UserAgentParser parser, ILoggerFactory loggerFactory = null) : base(queue, loggerFactory)
{
_slackService = slackService;
_mailer = mailer;
_projectRepository = projectRepository;
_appOptions = appOptions;
_emailOptions = emailOptions;
_userRepository = userRepository;
_eventRepository = eventRepository;
_cache = cacheClient;
_parser = parser;
}
protected override void StartService()
{
_log.Info("Starting service");
_log.InfoFormat("BaseDirectory: {0}", AppDomain.CurrentDomain.BaseDirectory);
_slackService = new SlackService(Settings.Default.BotKey);
_slackService.Connect().ContinueWith(Connected).ContinueWith((obj) =>
{
_log.Info("Starting check service");
_timer = new Timer(PeriodCheckService, null, 5 * 60 * 1000, 5 * 60 * 1000);
});
}
public async Task TestWeCallSlackFacadeAndCreateUserGroupOnlyIfNotExisting()
{
var slackFacadeSpy = new SlackFacadeSpy();
var logger = new LoggerFactory().CreateLogger <SlackService>();
var sut = new SlackService(slackFacadeSpy, logger);
var capabilityName = "foo";
await sut.EnsureUserGroupExists(capabilityName);
Assert.True(slackFacadeSpy.CreateUserGroupWasCalled);
Assert.Equal(capabilityName + "-members", slackFacadeSpy.CreateUserGroupHandle);
}
public override void OnException(ExceptionContext context)
{
try
{
SlackService slackService = new SlackService("https://hooks.slack.com/services/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");
string errorMessageBody = string.Format("{0} - {1}", context.Exception.Message, context.Exception.StackTrace);
slackService.PostMessage(errorMessageBody, "volkanakinpasa", "alerts");
}
catch
{
}
}
internal static SlackMessage Create(
SlackService slack,
string channel, SlackAPI.PostMessageResponse.Message message)
{
return(new SlackMessage()
{
Slack = slack,
Sender = slack.GetUser(message.user),
Channel = slack.GetChannel(channel),
Timestamp = message.ts,
Message = message.text
});
}
public IActionResult ForcePost()
{
try
{
var menus = RestaurantService.GetMenus();
SlackService.ProcessMenus(menus);
}
catch (Exception e)
{
Log.LogError("Error occured while calling ForcePost", e);
return(new StatusCodeResult(500));
}
return(new OkResult());
}
public override void OnException(ExceptionContext filterContext)
{
log.Error("", filterContext.Exception);
try
{
SlackService slackService = new SlackService("https://hooks.slack.com/services/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");
string errorMessageBody = string.Format("{0} - {1}", filterContext.Exception.Message, filterContext.Exception.StackTrace);
slackService.PostMessage(errorMessageBody, "volkanakinpasa", "alerts");
}
catch (Exception exInner)
{
log.Error("Error during logging error", exInner);
}
}
public async Task TestWeCallSlackFacadeAndNotCreateUserGroup()
{
var slackFacadeSpy = new SlackFacadeSpy();
var logger = new LoggerFactory().CreateLogger <SlackService>();
var sut = new SlackService(slackFacadeSpy, logger);
slackFacadeSpy.UserGroups.Add(new UserGroupDto
{
Handle = "foocapability-members",
Id = "bar",
Name = "foo"
});
var capabilityName = "foocapability";
await sut.EnsureUserGroupExists(capabilityName);
Assert.False(slackFacadeSpy.CreateUserGroupWasCalled);
}
public async Task SendAdvancedMessage()
{
var token = ConfigurationManager.AppSettings["SlackAccessToken"];
var channel = ConfigurationManager.AppSettings["TestingChannel"];
var text = "testmsg";
var blocks = JsonConvert.DeserializeObject <IBlock[]>(TestingData.AdvancedMessage1);
var config = new Mock <IContext>();
config.Setup(c => c.AppSettings).Returns(new AppSettings
{
ConfigurationGroups = new ConfigurationGroup[]
{
new ConfigurationGroup
{
SlackChannel = channel,
Sections = new System.Collections.Generic.Dictionary <string, ConfigSection>()
{
{ "contentservice", new ConfigSection
{
SectionHandlers = new Dictionary <string, SectionHandler>()
{
{ "published", new SectionHandler {
Label = "Content published", Value = true
} }
}
} }
}
}
}
});
config.Setup(c => c.GetMessage(It.IsAny <string>())).Returns(new MessageConfiguration {
Text = text, Blocks = blocks
});
var client = new SlackService(config.Object);
await client.SendMessageAsync("contentservice", "published", null);
}
public EventHandler(IConfiguration configuration)
{
_introductionChannelId = configuration["IntroductionChannelId"];
_privateIntroChannelId = configuration["PrivateIntroChannelId"];
_privateRegistrationChannelId = configuration["PrivateRegistrationChannelId"];
_privateProjectsChannelId = configuration["PrivateProjectsChannelId"];
_projectIdeasChannel = configuration["ProjectIdeasChannelId"];
_chatAppUserStorage = new ChatAppUserEntity();
_technologiesStorage = new TechnologyEntity();
_slackService = new SlackService();
_passwordHasher = new PasswordHasher <User>();
_mapper = new InitializeMapper().GetMapper;
_privilegedMembers = JsonConvert.DeserializeObject <PrivilegedMembersDto>(configuration["PrivilegedMembers"]);
_mainUrl = configuration["MainUrl"];
_keywords = new Dictionary <string, string>()
{
{ "dot", "." }, { "sharp", "#" }
};
}
public ProjectController(
IProjectRepository projectRepository,
IOrganizationRepository organizationRepository,
IEventRepository eventRepository,
IQueue <WorkItemData> workItemQueue,
BillingManager billingManager,
SlackService slackService,
IMapper mapper,
IQueryValidator validator,
IOptions <AppOptions> options,
ILoggerFactory loggerFactory
) : base(projectRepository, mapper, validator, loggerFactory)
{
_organizationRepository = organizationRepository;
_eventRepository = eventRepository;
_workItemQueue = workItemQueue;
_billingManager = billingManager;
_slackService = slackService;
_options = options;
}
public async Task TriggersSlackWebhook()
{
// Arrange
var requestMade = false;
var uri = new Uri("http://slack.api/web/hook");
var config = new Mock <IConfiguration>();
config
.SetupGet(conf => conf["Secrets:Slack:Enabled"])
.Returns(true.ToString());
config
.SetupGet(conf => conf["Secrets:Slack:WebHook"])
.Returns(uri.AbsoluteUri);
var responseHandler = new ResponseHandler();
responseHandler.AddAction(uri, () => (requestMade = true).ToString());
var httpClientFactory = new Mock <IHttpClientFactory>();
httpClientFactory
.Setup(factory => factory.BuildClient())
.Returns(new HttpClient(responseHandler));
var slack = new SlackService(
new Mock <ILogger <SlackService> >().Object,
config.Object,
httpClientFactory.Object
);
// Act
await slack.SendMessageAsync("The message");
// Assert
Assert.True(requestMade);
// Clean up
responseHandler.RemoveAction(uri);
}
public static void Setup(TestContext testContext)
{
slackService = new SlackService();
giphyUrl = "https://giphy.com/gifs/hero0fwar-karmawhore-rhyming-g9582DNuQppxC";
message = "You look happy!. Here's a fun gif for you";
}
static void TestSlacker()
{
var client = new SlackService(new ConsoleOutput(), "placeholder");
client.SendMessage("test message");
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <DataContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("TestDeviceBookingConnection")));
services.AddIdentity <User, Role>()
.AddEntityFrameworkStores <DataContext>();
services.Configure <IdentityOptions>(options =>
{
// Minimal requirements for password
options.Password.RequireDigit = false;
options.Password.RequiredLength = 3;
options.Password.RequireLowercase = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.User.RequireUniqueEmail = true;
});
// By default unauthorized requests to api would fallback to static SPA files
// Adding this to ensure 401 is returned
services.ConfigureApplicationCookie(options =>
{
options.LoginPath = new PathString("/login");
options.Events.OnRedirectToLogin = context =>
{
if (context.Request.Path.StartsWithSegments("/api") &&
context.Response.StatusCode == StatusCodes.Status200OK)
{
context.Response.Clear();
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
return(Task.FromResult <object>(null));
}
context.Response.Redirect(context.RedirectUri);
return(Task.FromResult <object>(null));
};
});
services.AddMvc();
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
var mapperConfig = new AutoMapper.MapperConfiguration(cfg =>
{
cfg.CreateMap <User, string>().ConvertUsing(s => { return((s == null) ? null : s.Name); });
cfg.CreateMap <Device, GetDevicesResponse>();
cfg.CreateMap <Office, GetOfficesResponse>();
cfg.CreateMap <Event, GetEventsResponseItem>();
cfg.CreateMap <User, GetUsersResponse>();
cfg.CreateMap <Office, GetOfficeResponse>();
});
var mapper = mapperConfig.CreateMapper();
services.AddSingleton(mapper);
services.AddScoped <IDevicesService, DevicesService>();
services.AddScoped <IOfficesService, OfficesService>();
services.AddScoped <IEventsService, EventsService>();
services.AddScoped <IReservationsService, ReservationsService>();
services.AddScoped <IUsersService, UsersService>();
ISlackService slackService = new SlackService(Configuration.GetValue <string>("SlackWebhook"));
services.AddSingleton(slackService);
}
public WebHooksJob(IQueue <WebHookNotification> queue, IProjectRepository projectRepository, SlackService slackService, IWebHookRepository webHookRepository, ICacheClient cacheClient, JsonSerializerSettings settings, IOptions <AppOptions> appOptions, ILoggerFactory loggerFactory = null) : base(queue, loggerFactory)
{
_projectRepository = projectRepository;
_slackService = slackService;
_webHookRepository = webHookRepository;
_cacheClient = cacheClient;
_jsonSerializerSettings = settings;
_appOptions = appOptions;
}
public IndexModule(SlackService slack, GitHubStatusAPIService gitservice)
{
var channel = ConfigurationManager.AppSettings["test:channel"];
var url = ConfigurationManager.AppSettings["octopussy:url"];
Get["/"] = parameters =>
{
return(View["index"]);
};
Get["/test/slack", true] = async(x, ct) =>
{
await slack.Send("hello world", channel);
return(View["index"]);
};
Get["/test/github/prsummary/{owner}/{repo}", true] = async(x, ct) =>
{
string owner = x.owner;
string repo = x.repo;
var summary = await gitservice.GetAllPullRequestStatus(owner, repo);
var payload = GenerateSlackMessagePR(await gitservice.GetRepositoryURL(owner, repo), owner, repo, "Nancy-Test", summary);
return(await slack.Send(payload, channel));
};
Get["/github/status/{owner}/{repo}/{reference}/{status?pending}/{context?all}", true] = async(x, ct) =>
{
bool all = x.context == "all";
string owner = x.owner;
string repo = x.repo;
string reference = x.reference;
var status = (Octokit.CommitState)Enum.Parse(typeof(Octokit.CommitState), x.status, true);
if (all)
{
var statusChecks = new List <Tuple <string, string> >();
statusChecks.Add(new Tuple <string, string>("build", "Verify build has had no errors"));
statusChecks.Add(new Tuple <string, string>("test-unit", "Ensure unit tests have passed"));
statusChecks.Add(new Tuple <string, string>("test-meerkat", "Ensure Meerkat tests have passed"));
statusChecks.Add(new Tuple <string, string>("rally", "Review rally items"));
statusChecks.Add(new Tuple <string, string>("code-review", "Organise code review by a team member"));
foreach (var check in statusChecks)
{
await gitservice.SetStatus(owner, repo, reference, check.Item1, status, check.Item2, GeneratePullRequestSuccessURL(url, owner, repo, reference, check.Item1, CommitState.Success));
}
}
else
{
await gitservice.SetStatus(owner, repo, reference, x.context, status, "", GeneratePullRequestSuccessURL(url, owner, repo, reference, x.context, Octokit.CommitState.Success));
}
return(View["index"]);
};
Post["/slack", true] = async(x, ct) =>
{
var data = this.Bind <SlackPostData>();
if (data != null)
{
if (slack.VerifySlackToken(data.token))
{
if (data.command.StartsWith("github"))
{
// Do stuff then post result to slack
var split = data.text.Split('/');
if (split.Length >= 2)
{
string owner = split[0];
string repo = split[1];
var summary = await gitservice.GetAllPullRequestStatus(owner, repo);
var payload = GenerateSlackMessagePR(await gitservice.GetRepositoryURL(owner, repo), owner, repo, data.user_name, summary);
await slack.Send(payload, data.channel_name);
return("Response sent to slack");
}
}
}
else
{
return("Hey, " + data.user_name + ", your request was not validated as the slack Token didnt match (" + data.token + ")");
}
}
return("I don't know what's going on here, Sorry");
};
}
protected override void StartService()
{
Log.Information($"Starting service {Settings.Default.BotKey.Substring(1, 5)}");
_slackService = new SlackService(Settings.Default.BotKey);
_slackService.Connect().ContinueWith(Connected);
}
public CognitoController(GiphyService giphyService, SlackService slackService, AylienSentimentFetch aylienSentimentFetch)
{
_giphyService = giphyService;
_slackService = slackService;
_aylienService = aylienSentimentFetch;
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
bool simple = !(req.Headers["format"] == "extended");
var channel = req.Headers["channel"];
if (!string.IsNullOrWhiteSpace(channel))
{
if (!channel.ToString().StartsWith("#"))
{
channel = "#" + channel;
}
}
string requestBody = new StreamReader(req.Body).ReadToEnd();
var request = JsonConvert.DeserializeObject <WebhookRequest>(requestBody);
//var message = data?.message?.text;
var detailedMessage = request.DetailedMessage.text;
// important - get this data
var resourceLink = request.Resource.url;
var changesData = await GetVstsResource($"{resourceLink}/changes");
var changes = JsonConvert.DeserializeObject <Changes>(changesData);
var changesCount = changes.count;
var changesText = "";
foreach (var change in changes.value)
{
changesText +=
$"<{change.displayUri}|{change.message}> by *{change.Author.displayName}*\n";
if (!simple)
{
changesText += $"{change.message}\n\n";
}
}
var resource = await GetVstsResource(resourceLink);
var resourceData = JsonConvert.DeserializeObject <ResourceDetails>(resource);
var projectName = resourceData.Project.Name;
var buildLink = resourceData._Links.Web.Href;
var sourceBranch = resourceData.SourceBranch;
var sourceVersion = resourceData.SourceVersion;
var repository = resourceData.Repository.Id;
var definitionName = request.Resource.definition.name;
var gitUrl = $"{repository.Replace(".git", "")}/commit/{sourceVersion}";
var timeline = await GetVstsResource(resourceData._Links.Timeline.Href);
var timeLineData = JsonConvert.DeserializeObject <Timeline>(timeline);
var failingTask = timeLineData.Records.FirstOrDefault(x => x.Result == "failed");
var slackService = new SlackService(log, KeyManager.GetSecret("SlackWebhookUrl"));
var model = new SlackMessageModel
{
username = "******",
icon_emoji = ":vsts:",
text = $"*{projectName}/{definitionName} - {failingTask.Name} failed*",
channel = channel,
attachments = new List <SlackMessageModel.SlackAttachment>()
{
new SlackMessageModel.SlackAttachment
{
color = "#ff0000",
pretext = $"Repository: {repository}\nBranch: {sourceBranch}\nCommit: {sourceVersion}",
title = $"{changesCount} Change(s) in the build: ",
text = changesText,
actions = new[]
{
new SlackMessageModel.SlackAction
{
type = "button",
text = ":octocat: Git Repo Url",
url = repository
},
new SlackMessageModel.SlackAction
{
type = "button",
text = ":octocat: Git Commit Url",
url = gitUrl
},
new SlackMessageModel.SlackAction
{
type = "button",
text = ":vsts: VSTS Url",
url = buildLink
}
}
}
}
};
if (!simple)
{
model.attachments.Add(new SlackMessageModel.SlackAttachment
{
color = "#ff0000",
title = "Build message",
text = $"{detailedMessage}"
});
}
slackService.PostToSlack(model);
return(new OkObjectResult(""));
}
public RatingController(SessionFactory sessionFactory, SlackService slackService, RatingRepository ratingRepository)
{
this.sessionFactory = sessionFactory;
this.slackService = slackService;
this.ratingRepository = ratingRepository;
}
public EventsController(ILogger <EventsController> logger, SlackService slackService, MagicService magicLeagueService)
{
this.logger = logger;
this.magicLeagueService = magicLeagueService;
}
public void Setup()
{
_mockSlackClient = new Mock <ISlackClient>();
_slackService = new SlackService(_mockSlackClient.Object);
}
internal SlackUsersEndpoint(SlackService service) {
Service = service;
}
public WebHooksJob(IQueue <WebHookNotification> queue, IProjectRepository projectRepository, SlackService slackService, IWebHookRepository webHookRepository, JsonSerializerSettings settings, ILoggerFactory loggerFactory = null) : base(queue, loggerFactory)
{
_projectRepository = projectRepository;
_slackService = slackService;
_webHookRepository = webHookRepository;
_jsonSerializerSettings = settings;
}
public SlackApiController(SlackService slackService)
{
this.slackService = slackService;
}
internal SlackAuthenticationEndpoint(SlackService service) {
Service = service;
}
public DaemonTask(StravaService stravaService, AthleteRepository athleteRepository, SlackService slackService, MessageFactory messageFactory, ILogger <TimedBackgroundWorker> logger)
{
_stravaService = stravaService;
_athleteRepository = athleteRepository;
_slackService = slackService;
_messageFactory = messageFactory;
_logger = logger;
}
public BackupControllerViewModel(IEventAggregator eventAggregator, IWindowManager windowManager, IMessageBoxService msgBoxService, ScheduledBackupService scheduledBackupService, SlackService slackService)
{
EVENT_AGGREGATOR = eventAggregator;
EVENT_AGGREGATOR.Subscribe(this);
WINDOW_MANAGER = windowManager;
MSG_BOX_SERVICE = msgBoxService;
SLACK_SERVICE = slackService;
m_scheduledBackupService = scheduledBackupService;
}
