public async Task <Capability> CreateCapability(string name, string description)
{
var capability = await _capabilityFactory.Create(name, description);
await _capabilityRepository.Add(capability);
return(capability);
}
public async Task HandleAsync(CapabilityCreatedDomainEvent domainEvent)
{
var createChannelResponse = await _slackFacade.CreateChannel(domainEvent.Payload.CapabilityName);
UserGroupDto userGroup = null;
try
{
userGroup = await _slackService.EnsureUserGroupExists(domainEvent.Payload.CapabilityName);
}
catch (SlackFacadeException ex)
{
_logger.LogError($"Issue with Slack API during CreateUserGroup: {ex} : {ex.Message}");
}
var channelName = createChannelResponse?.Channel?.Name;
if (createChannelResponse.Ok)
{
var channelId = new ChannelId(createChannelResponse?.Channel?.Id);
_logger.LogInformation($"Slack channel '{channelName}' for capability '{domainEvent.Payload.CapabilityName}' created with ID: {channelId}");
var userGroupId = userGroup?.Id;
// Save even without user group.
var capability = Capability.Create(
id: domainEvent.Payload.CapabilityId,
name: domainEvent.Payload.CapabilityName,
slackChannelId: channelId,
slackUserGroupId: userGroupId);
_logger.LogInformation($"Capability id: '{capability.Id}' name: '{capability.Name}' slackChannelId: '{capability.SlackChannelId}', userGroupId: '{capability.SlackUserGroupId}'");
await _capabilityRepository.Add(capability);
// Notify channel about handle.
var sendNotificationResponse = await _slackFacade.SendNotificationToChannel(
channelIdentifier : channelId.ToString(),
message :
$"Thank you for creating capability '{capability.Name}'.\n" +
$"This channel along with handle @{userGroup.Handle} has been created.\n" +
"Use the handle to notify capability members.\n" +
$"If you want to define a better handle, you can do this in the '{userGroup.Name}'");
// Pin message.
await _slackFacade.PinMessageToChannel(channelId.ToString(), sendNotificationResponse.TimeStamp);
}
else
{
_logger.LogError($"Error creating Slack channel '{channelName}', Error: '{createChannelResponse.Error}'");
}
}
public async Task <Capability> CreateCapability(string name, string description)
{
if (!_nameValidationRegex.Match(name).Success)
{
throw new CapabilityValidationException("Name must be a string of length 3 to 32. consisting of only alphanumeric ASCII characters, starting with a capital letter. Underscores and hyphens are allowed.");
}
var capability = Capability.Create(name, description);
await _capabilityRepository.Add(capability);
await _roleService.CreateRoleFor(capability);
return(capability);
}
public async Task <IActionResult> AddConnection(ConnectionDto connection)
{
if (string.IsNullOrEmpty(connection.ClientId))
{
return(BadRequest("ClientId ID is required."));
}
if (string.IsNullOrEmpty(connection.ClientType))
{
return(BadRequest("ClientType is required."));
}
if (string.IsNullOrEmpty(connection.ClientName))
{
return(BadRequest("ClientName is required."));
}
if (string.IsNullOrEmpty(connection.ChannelId))
{
return(BadRequest("Channel ID is required."));
}
if (string.IsNullOrEmpty(connection.ChannelType))
{
return(BadRequest("ChannelType is required."));
}
if (string.IsNullOrEmpty(connection.ChannelName))
{
return(BadRequest("ChannelName is required."));
}
var userGroup = await _slackService.EnsureUserGroupExists(connection.ClientName);
var capability = Capability.Create(Guid.Parse(connection.ClientId), connection.ClientName,
connection.ChannelId, userGroup.Id);
await _capabilityRepository.Add(capability);
var response = await _slackFacade.JoinChannel(((ChannelName)connection.ChannelName).ToString());
return(Accepted(response.Channel));
}