public void CheckIncidentsStatus(ILogger log)
{
log.LogInformation("Starting incident status check with service management system...");
List <AlertIncidentEntity> alertIncidents = GetAllAlertIncidents();
log.LogInformation($"Found {alertIncidents.Count} open incidents, checking status if necessary..");
ServiceManagementStatusResponseDto incidentsStatus = serviceManagemement.GetIncidentsStatus(alertIncidents, log);
foreach (string incidentId in incidentsStatus.result.Keys)
{
ServiceManagementStatus status = incidentsStatus.result[incidentId];
log.LogInformation($"Got new service management status for incident {incidentId}: {status.state}");
if (status.state == "Resolved" || status.state == "Closed")
{
AlertIncidentEntity alertIncident = GetAlertIncident("SNOW", incidentId);
if (alertIncident != null)
{
AlertEntity alert = GetAlert(alertIncident.AlertPartitionId, alertIncident.AlertRowId);
if (alert != null)
{
DeleteAlert(alert);
}
DeleteAlertIncident(alertIncident);
}
}
}
}
public static PSSecurityAlertEntity ConvertToPSType(this AlertEntity value)
{
return(new PSSecurityAlertEntity
{
Type = value.Type
});
}
private void ViewAlert(AlertEntity alert)
{
Navigator.Navigate(alert, new NavigateOptions()
{
Closed = (o, e) => Dispatcher.Invoke(() => ReloadAlerts()),
});
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
string result = "Alert successfully confirmed.";
// parse query parameter
string IncidentId = "";
if (req.GetQueryParameterDictionary().ContainsKey("incidentid"))
{
IncidentId = req.GetQueryParameterDictionary()["incidentid"];
log.LogInformation($"Preparing to confirm SNOW incident {IncidentId}");
AlertIncidentEntity alertIncident = alertUtils.GetAlertIncident("SNOW", IncidentId);
if (alertIncident != null)
{
AlertEntity alert = alertUtils.GetAlert(alertIncident.AlertPartitionId, alertIncident.AlertRowId);
alertUtils.DeleteAlert(alert);
alertUtils.DeleteAlertIncident(alertIncident);
}
}
else
{
log.LogInformation("NO incidentid was passed, so checking all open incidents..");
alertUtils.CheckIncidentsStatus(log);
}
log.LogInformation("Finished checking incident status");
return((ActionResult) new OkObjectResult(result));
}
private static void AlertEvents_Saved(AlertEntity ident, SavedEventArgs args)
{
if (ident.Recipient != null)
{
NotifyOnCommit(ident.Recipient);
}
}
private void WriteToSqlDb(string aAlert)
{
AlertEntity lNewAlert = JsonConvert.DeserializeObject <AlertEntity>(aAlert);
_alertsDb.Add(lNewAlert);
_alertsDb.SaveChanges();
}
private void btnNewAlert_Click(object sender, RoutedEventArgs e)
{
if (DataContext == null)
{
return;
}
AlertEntity alert = CreateAlert((Entity)DataContext);
ViewAlert(alert);
}
private string?ReplacePlaceHolders(string?value, AlertEntity alert)
{
if (value == null)
{
return(null);
}
return(TextPlaceHolder.Replace(value, g =>
{
return GetPropertyValue(alert, g.Groups["prop"].Value)?.ToString() !;
}));
}
public async static Task ProcessAlertMessage([ServiceBusTrigger("sumppumpalerts")] AlertPayload payload)
{
var newAlert = new AlertEntity()
{
PartitionKey = payload.DeviceId,
RowKey = payload.Timestamp.ToRowKey(),
Type = (AlertType)payload.Type,
WaterLevel = payload.WaterLevel,
PumpRunning = payload.PumpRunning
};
AlertRepository.Insert(newAlert);
}
public ServiceManagementResponseDto CreateIncident(AlertEntity alert, ILogger log)
{
string number = System.DateTime.Now.Ticks.ToString();
ServiceManagementResponseDto result = new ServiceManagementResponseDto();
result.result = new ServiceManagementResponse()
{
number = number,
url = $"https://yyy.servicenow.com/yyyyyy/yyy?incident={number}"
};
return(result);
}
private static object?GetPropertyValue(AlertEntity alert, string expresion)
{
var parts = expresion.SplitNoEmpty('.');
var result = SimpleMemberEvaluator.EvaluateExpression(alert, parts);
if (result is Result <object?> .Error e)
{
throw new InvalidOperationException(e.ErrorText);
}
if (result is Result <object?> .Success s)
{
return(s.Value);
}
throw new UnexpectedValueException(result);
}
public static AlertEntity CreateAlert <T>(this Lite <T> entity, string text, AlertTypeEntity alertType, DateTime?alertDate = null, Lite <IUserEntity> user = null, string title = null) where T : class, IEntity
{
if (Started == false)
{
return(null);
}
var result = new AlertEntity
{
AlertDate = alertDate ?? TimeZoneManager.Now,
CreatedBy = user ?? UserHolder.Current?.ToLite(),
Text = text,
Title = title,
Target = (Lite <Entity>)entity,
AlertType = alertType
};
return(result.Execute(AlertOperation.Save));
}
public void DeleteAlert(AlertEntity alert)
{
// Retrieve the storage account from the connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(System.Environment.GetEnvironmentVariable("StorageConnectionString"));
// Create the table client.
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
// Create the CloudTable object that represents the "people" table.
CloudTable table = tableClient.GetTableReference("Alerts");
table.CreateIfNotExistsAsync().Wait();
// Create the TableOperation object that inserts the customer entity.
TableOperation deleteOperation = TableOperation.Delete(alert);
// Execute the insert operation.
table.ExecuteAsync(deleteOperation);
}
/// <summary>
/// The GetAlertParameters method returns the SubscriptionId and AlertRuleName if they are available in the payload
/// </summary>
/// <param name="payload">The JSON payload from Azure Alerting</param>
/// <returns>AlertParameters object with SubscriptionId and AlertRuleName</returns>
public AlertEntity[] LoadOrCreateAlerts(string payload, ILogger log)
{
List <AlertEntity> results = new List <AlertEntity>();
Newtonsoft.Json.Linq.JObject obj = Newtonsoft.Json.Linq.JObject.Parse(payload);
if (obj != null && obj["data"] != null)
{
string AlertRuleName = "NO-NAME-FOUND";
if (obj["data"]["AlertRuleName"] != null)
{
AlertRuleName = obj["data"]["AlertRuleName"].ToString();
}
string LogAnalyticsUrl = "";
if (obj["data"]["LinkToSearchResults"] != null)
{
LogAnalyticsUrl = obj["data"]["LinkToSearchResults"].ToString();
}
AlertResult[] alertResults = GetAlertResults(AlertRuleName, payload, obj, log);
foreach (AlertResult result in alertResults)
{
// Add computer to AlertRuleName
if (!String.IsNullOrEmpty(result.PartitionKey) && !String.IsNullOrEmpty(AlertRuleName))
{
AlertEntity alert = GetAlert(result.PartitionKey, AlertRuleName);
if (alert == null)
{
alert = new AlertEntity(result.PartitionKey, AlertRuleName);
alert.Payload = payload;
alert.SearchIntervalStartTimeUtc = DateTime.Parse(obj["data"]["SearchIntervalStartTimeUtc"].ToString());
alert.SearchIntervalEndTimeUtc = DateTime.Parse(obj["data"]["SearchIntervalEndtimeUtc"].ToString());
alert.LogAnalyticsUrl = LogAnalyticsUrl;
alert.Resource = result.ResourceName;
alert.ClientInstance = result.InstanceName;
alert.Description = result.Description;
alert.Type = result.Type.ToString();
}
else
{
alert.LastOccuranceTimestamp = DateTime.Now;
alert.Counter++;
}
results.Add(alert);
if (String.IsNullOrEmpty(alert.IncidentId))
{
// We don't yet have an IncidentId for this alert
ServiceManagementResponseDto incident = serviceManagemement.CreateIncident(alert, log);
if (incident != null && incident.result != null)
{
alert.IncidentId = incident.result.number;
alert.IncidentUrl = incident.result.url;
}
}
log.LogInformation("Update Alerts table: " + Newtonsoft.Json.JsonConvert.SerializeObject(alert));
InsertUpdateAlert(alert);
if (!String.IsNullOrEmpty(alert.IncidentId))
{
// Insert record of incident ID
AlertIncidentEntity incidentEntity = new AlertIncidentEntity("SNOW", alert.IncidentId);
incidentEntity.AlertPartitionId = alert.PartitionKey;
incidentEntity.AlertRowId = alert.RowKey;
incidentEntity.IncidentUrl = alert.IncidentUrl;
InsertUpdateAlertIncident(incidentEntity);
}
}
}
}
return(results.ToArray());
}
public ServiceManagementResponseDto CreateIncident(AlertEntity alert, ILogger log)
{
ServiceManagementResponseDto response = null;
using (HttpClient client = new HttpClient())
{
string serviceManagementCredentials = System.Environment.GetEnvironmentVariable("ServiceManagementCredentials");
if (!String.IsNullOrEmpty(serviceManagementCredentials))
{
var byteArray = Encoding.ASCII.GetBytes(serviceManagementCredentials);
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
}
string serviceManagementUserAgent = System.Environment.GetEnvironmentVariable("ServiceManagementUserAgent");
if (!String.IsNullOrEmpty(serviceManagementUserAgent))
{
client.DefaultRequestHeaders.Add("User-Agent", serviceManagementUserAgent);
}
ServiceManagementDto payload = new ServiceManagementDto()
{
caller_id = System.Environment.GetEnvironmentVariable("ServiceManagementCallerId"),
opened_by = System.Environment.GetEnvironmentVariable("ServiceManagementUser"),
business_service = System.Environment.GetEnvironmentVariable("ServiceManagementBusinessService"),
it_service = System.Environment.GetEnvironmentVariable("ServiceManagementITService"),
contact_type = System.Environment.GetEnvironmentVariable("ServiceManagementContactType"),
short_description = alert.AlertName + " " + alert.ClientInstance,
description = alert.Description + " " + alert.LogAnalyticsUrl,
assignment_group = System.Environment.GetEnvironmentVariable("ServiceManagementAssignmentGroup"),
location = System.Environment.GetEnvironmentVariable("ServiceManagementLocation"),
gravity = System.Environment.GetEnvironmentVariable("ServiceManagementGravity"),
impact = System.Environment.GetEnvironmentVariable("ServiceManagementImpact"),
stage = System.Environment.GetEnvironmentVariable("ServiceManagementStage")
};
if (alert.Type == Common.AlertTypes.Disk)
{
payload.short_description = alert.AlertName + " (" + alert.Resource + ") " + alert.ClientInstance;
}
var content = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(payload), Encoding.UTF8, "application/json");
string snowUrl = System.Environment.GetEnvironmentVariable("ServiceManagementUrl") + "/create_incident";
HttpResponseMessage msg = client.PostAsync(snowUrl, content).Result;
if (msg.IsSuccessStatusCode)
{
var JsonDataResponse = msg.Content.ReadAsStringAsync().Result;
response = Newtonsoft.Json.JsonConvert.DeserializeObject <ServiceManagementResponseDto>(JsonDataResponse);
}
else
{
var JsonDataResponse = msg.Content.ReadAsStringAsync().Result;
string responseMessage = "";
if (JsonDataResponse != null)
{
responseMessage = JsonDataResponse.ToString();
}
log.LogError($"Could not reach SNOW server: {msg.ToString()} - {responseMessage}");
}
}
return(response);
}
public static async Task Run([QueueTrigger("messagesqueue", Connection = "AzureWebJobsStorage")] string myQueueItem, TraceWriter log)
{
log.Info($"Processing: {myQueueItem}");
//variables
var azureWebJobsStorage = CloudConfigurationManager.GetSetting("AzureWebJobsStorage");
var messagesTableContainerName = CloudConfigurationManager.GetSetting("MessagesTableContainerName");
var messagesTablePartitionKey = CloudConfigurationManager.GetSetting("MessagesTablePartitionKey");
var alertsTableContainerName = CloudConfigurationManager.GetSetting("AlertsTableContainerName");
var alertsTablePartitionKey = CloudConfigurationManager.GetSetting("AlertsTablePartitionKey");
var textAnalyticsApiKey = CloudConfigurationManager.GetSetting("TextAnalyticsApiKey");
var textAnalyticsApiUrl = CloudConfigurationManager.GetSetting("TextAnalyticsApiUrl");
var luisApiKey = CloudConfigurationManager.GetSetting("LuisApiKey");
var luisApiUrl = CloudConfigurationManager.GetSetting("LuisApiUrl");
var bullyingApiKey = CloudConfigurationManager.GetSetting("BullyingApiKey");
var bullyingApiUrl = CloudConfigurationManager.GetSetting("BullyingApiUrl");
var storageAccount = CloudStorageAccount.Parse(azureWebJobsStorage);
var tableClient = storageAccount.CreateCloudTableClient();
//parse the message JSON to a dynamic object, then entity
dynamic queueItem = JObject.Parse(myQueueItem);
var chatMessageEntity = new ChatMessageEntity(messagesTablePartitionKey, Guid.NewGuid().ToString());
chatMessageEntity.Message = queueItem.Message;
chatMessageEntity.Time = queueItem.Time;
chatMessageEntity.UserId = queueItem.UserId;
chatMessageEntity.ChatId = queueItem.ChatId;
//Get Text Analytics Sentiment data and add to entity
var sentimentData = await GetTextAnalyticsData(textAnalyticsApiUrl, textAnalyticsApiKey, queueItem.Message.ToString(), "sentiment");
SentimentResponse sentiment = JsonConvert.DeserializeObject <SentimentResponse>(sentimentData);
chatMessageEntity.Sentiment = sentiment.documents[0].score;
log.Info($"Sentiment: {chatMessageEntity.Sentiment}");
//Get Text Analytics key phrase data and add to entity
var keyPhrasesData = await GetTextAnalyticsData(textAnalyticsApiUrl, textAnalyticsApiKey, queueItem.Message.ToString(), "keyPhrases");
KeyPhrasesResponse keyPhrases = JsonConvert.DeserializeObject <KeyPhrasesResponse>(keyPhrasesData);
chatMessageEntity.KeyPhrases = string.Join(",", keyPhrases.documents[0].keyPhrases);
log.Info($"Key Phrases: {chatMessageEntity.KeyPhrases }");
//Do LUIS entity and intent extraction here
var luisData = await GetLUISData(luisApiUrl, luisApiKey, queueItem.Message.ToString());
LuisResponse luis = JsonConvert.DeserializeObject <LuisResponse>(luisData);
if (luis.topScoringIntent.intent != "None")
{
//create an alert
var alertEntity = new AlertEntity(alertsTablePartitionKey, Guid.NewGuid().ToString());
alertEntity.AlertCategory = ResolveCategory(luis.topScoringIntent.intent);
alertEntity.AlertText = queueItem.Message.ToString();
alertEntity.ChatMessageId = chatMessageEntity.RowKey.ToString();
alertEntity.StartIndex = -1;
alertEntity.EndIndex = -1;
alertEntity.ChatId = chatMessageEntity.ChatId;
await LogAlert(tableClient, alertsTableContainerName, alertEntity);
}
if (luis.entities.Count > 0)
{
//create an alert for each entity
foreach (var entity in luis.entities)
{
//create an alert
var alertEntity = new AlertEntity(alertsTablePartitionKey, Guid.NewGuid().ToString());
alertEntity.AlertCategory = ResolveCategory(entity.type);
alertEntity.AlertText = entity.entity;
alertEntity.ChatMessageId = chatMessageEntity.RowKey.ToString();
alertEntity.StartIndex = entity.startIndex;
alertEntity.EndIndex = entity.endIndex;
alertEntity.ChatId = chatMessageEntity.ChatId;
await LogAlert(tableClient, alertsTableContainerName, alertEntity);
}
}
//bullying detection
var bullyingData = await GetBullyingData(bullyingApiUrl, bullyingApiKey, queueItem.Message.ToString());
// Create the TableOperation object that inserts the entity
var messagesTable = tableClient.GetTableReference(messagesTableContainerName);
var messageInsertOperation = TableOperation.Insert(chatMessageEntity);
messagesTable.Execute(messageInsertOperation);
log.Info($"Processed: {myQueueItem}");
}
public static async Task <bool> LogAlert(CloudTableClient client, string alertsTableContainerName, AlertEntity alertEntity)
{
var alertsTable = client.GetTableReference(alertsTableContainerName);
var alertInsertOperation = TableOperation.Insert(alertEntity);
await alertsTable.ExecuteAsync(alertInsertOperation);
return(true);
}
public void Save(AlertEntity alunoEntity)
{
AlertRepository.Save(alunoEntity);
}
