public async Task <Topic> ToNewSpecialObject(IStandardInstance instance)
{
string projectId = await ProjectIdProvider.GetProjectId(instance.Identifiers, await _dbService.GetAllProjectMappings());
var author = instance.Author == null ? null : await _dbService.GetEasyAccessUserFrom(instance.Author.UserMap[_configSettings.UserColumnName]);
var assignee = instance.Assignee == null ? null : await _dbService.GetEasyAccessUserFrom(instance.Assignee.UserMap[_configSettings.UserColumnName]);
var newTopic = new Topic()
{
Status = instance.Status,
Priority = instance.Priority,
AuthorId = author?.Id,
AuthorName = author?.Name,
AuthorEmail = author?.Email,
AssignedToId = assignee?.Id,
AssignedToEmail = assignee?.Email,
AssignedToName = assignee?.Name,
CreationDate = instance.Created,
Title = "[" + instance.MessageOrigin.Split('_')[0] + "] | " + instance.Summary,
TopicType = instance.Type,
ProjectId = projectId,
Labels = instance.Labels
};
return(newTopic);
}
public static bool OfInterest(IStandardInstance contextMessage, string systemIdentifier)
{
if (contextMessage.MessageOrigin.Equals(systemIdentifier))
{
return(false);
}
return(true);
}
public async Task <IStandardInstance> HandleUpdate(IStandardInstance instance)
{
if (instance.Identifiers.ContainsKey(InstanceKeyNames.EASY_ACCESS_TOPIC))
{
var updatedInstance = await _resourceService.UpdateInstanceAsync(instance);
return(updatedInstance);
}
return(null);
}
public async Task <IStandardInstance> HandleCreation(IStandardInstance instance)
{
IStandardInstance handledInstance = new JiraStandardIssue();
if (!instance.Identifiers.ContainsKey(InstanceKeyNames.JIRA_ISSUE))
{
handledInstance = await _resourceService.CreateInstanceAsync(instance);
await _resourcePublisher.PublishKeyMap(instance.Identifiers);
}
return(handledInstance);
}
public async Task <IStandardInstance> HandleCreation(IStandardInstance instance)
{
IStandardInstance handledInstance = new StandardTopic();
if (!instance.Identifiers.ContainsKey(InstanceKeyNames.EASY_ACCESS_TOPIC))
{
Debug.WriteLine("Creating new Topic from instance from: " + instance.MessageOrigin);
handledInstance = await _resourceService.CreateInstanceAsync(instance);
await _resourcePublisher.PublishKeyMap(instance.Identifiers);
}
return(handledInstance);
}
private async Task UpdateStatusAndPriority(IStandardInstance instance, Topic updatedTopic)
{
var modifiedUser = (instance.ModifiedUser == null) ? null : await _dbService.GetEasyAccessUserFrom(instance.ModifiedUser.UserMap[_settings.UserColumnName]);
if (!(updatedTopic.Status?.ToLower() == instance.Status?.ToLower()))
{
await UpdateStatusOfTopic(updatedTopic, instance.Status, modifiedUser);
}
if (!(updatedTopic.Priority?.ToLower() == instance.Priority?.ToLower()))
{
await UpdatePriorityOfTopic(updatedTopic, instance.Priority, modifiedUser);
}
}
public async Task <IStandardInstance> UpdateInstanceAsync(IStandardInstance instance)
{
try
{
string projectId = await ProjectIdProvider.GetProjectId(instance.Identifiers, await _dbService.GetAllProjectMappings());
string requestUri = "projects/" + projectId + "/topics/" + instance.Identifiers[InstanceKeyNames.EASY_ACCESS_TOPIC].Id;
//fetch the old topic first
var oldTopicResponse = await _resourceClient.RestClient.GetAsync(requestUri);
if (!oldTopicResponse.IsSuccessStatusCode)
{
throw new ResourceException("Error getting instance at " + requestUri + ". StatusCode=" + oldTopicResponse.StatusCode);
}
var oldTopic = await oldTopicResponse.Content.ReadAsAsync <Topic>();
//map the instance and merge it into the old topic
var topicToBeUpdated = await _instanceMapper.ToUpdatedSpecialObject(instance, oldTopic);
string json = topicToBeUpdated.ToJson();
Debug.WriteLine("Topic to be updated: id=" + topicToBeUpdated.Id + ", projectId=" + topicToBeUpdated.ProjectId + ", title=" + topicToBeUpdated.Title);
//update the topic
var updatedTopicResponse = await _resourceClient.RestClient.PutAsync(requestUri, new StringContent(json, Encoding.UTF8,
"application/json"));
if (!updatedTopicResponse.IsSuccessStatusCode)
{
throw new ResourceException("Error updating instance with id=" + topicToBeUpdated.Id + ". StatusCode=" + updatedTopicResponse.StatusCode);
}
var updatedTopic = await updatedTopicResponse.Content.ReadAsAsync <Topic>();
//EasyAccess status and priority is updated via comments.
await UpdateStatusAndPriority(instance, updatedTopic);
Debug.WriteLine("Topic was updated.");
}
catch (Exception e)
{
Debug.WriteLine("Error updating topic...");
Debug.WriteLine(e.Message, e.StackTrace);
}
return(instance);
}
public async Task <IStandardInstance> UpdateInstanceAsync(IStandardInstance instance)
{
var issueToBeUpdated = await _resourceClient.RestClient.Issues.GetIssueAsync(instance.Identifiers[InstanceKeyNames.JIRA_ISSUE].Id);
var updatedIssue = await _issueMapper.ToUpdatedSpecialObject(instance, issueToBeUpdated);
await updatedIssue.SaveChangesAsync();
if (instance.Status != null && instance.Status.ToLower() != updatedIssue.Status?.Name?.ToLower())
{
await updatedIssue.WorkflowTransitionAsync(instance.Status);
}
return(null);
}
private static string GetTitle(IStandardInstance instance)
{
var summary = instance.Summary;
if (summary.StartsWith("[EasyAccess]"))
{
return(summary.Substring(summary.IndexOf('|') + 1));
}
else if (summary.StartsWith('[') && summary.Contains("] | "))
{
return(summary);
}
else
{
return("[" + instance.MessageOrigin.Split('_')[0] + "] | " + summary);
}
}
public static Issue ToUpdatedJiraIssue(IStandardInstance instance, Jira jiraClient, Issue oldIssue)
{
string summary = GetSummary(instance);
oldIssue.Type = instance.Type;
oldIssue.Summary = summary;
oldIssue.Reporter = instance.Author.UserMap[userColumnName];
oldIssue.Priority = instance.Priority;
try
{
oldIssue.Assignee = instance.Assignee.UserMap[userColumnName];
}
catch (Exception e)
{
Debug.WriteLine("No assigned user");
}
return(oldIssue);
}
public static Issue ToNewJiraIssue(IStandardInstance instance, Jira jiraClient, string projectKey)
{
var jiraIssue = new Issue(jiraClient, projectKey)
{
Type = instance.Type,
Reporter = instance.Author.UserMap[userColumnName],
Summary = "[" + instance.MessageOrigin.Split('_')[0] + "] | " + instance.Summary,
Priority = instance.Priority
};
try
{
jiraIssue.Assignee = instance.Assignee.UserMap[userColumnName];
} catch (Exception e)
{
Debug.WriteLine("No assigned user");
}
foreach (var identifier in instance.Identifiers)
{
if (identifier.Value.Id != null)
{
try
{
jiraIssue[identifier.Key + "Id"] = identifier.Value.Id;
jiraIssue[identifier.Key + "Url"] = identifier.Value.Url;
}
catch (Exception e)
{
Debug.WriteLine("Error adding identifier to field:");
Debug.WriteLine(e.StackTrace);
}
}
}
return(jiraIssue);
}
public async Task <IStandardInstance> CreateInstanceAsync(IStandardInstance instance)
{
try
{
var newTopic = await _instanceMapper.ToNewSpecialObject(instance);
string requestUri = "projects/" + newTopic.ProjectId + "/topics";
string json = newTopic.ToJson();
Debug.WriteLine("creating topic: projectId=" + newTopic.ProjectId + ", title=" + newTopic.Title);
var response = await _resourceClient.RestClient.PostAsync(requestUri, new StringContent(json, Encoding.UTF8,
"application/json"));
var createdTopic = await response.Content.ReadAsAsync <Topic>();
var topicUrl = "Project/" + createdTopic.ProjectId + "/Topics#/list/topic/" + createdTopic.Id;
instance.Identifiers.Add(InstanceKeyNames.EASY_ACCESS_TOPIC, new Identifiers()
{
Id = createdTopic.Id,
ProjectId = createdTopic.ProjectId,
Url = _settings.HomeUri + topicUrl
});
await UpdateInstanceIdMap(instance.Identifiers);
return(instance);
}
catch (Exception e)
{
Debug.WriteLine("Failed to create instance..", e.StackTrace);
}
return(null);
}
public async Task <Topic> ToUpdatedSpecialObject(IStandardInstance instance, Topic oldTopic)
{
var assignee = instance.Assignee == null ? null : await _dbService.GetEasyAccessUserFrom(instance.Assignee.UserMap[_configSettings.UserColumnName]);
var author = instance.Author == null ? null : await _dbService.GetEasyAccessUserFrom(instance.Author.UserMap[_configSettings.UserColumnName]);
var result = oldTopic;
result.TopicType = instance.Type;
result.Title = GetTitle(instance);
result.AssignedToId = assignee?.Id;
result.AssignedToName = assignee?.Name;
result.AssignedToEmail = assignee?.Email;
result.AuthorId = author?.Id;
result.AuthorEmail = author?.Email;
result.AuthorName = author?.Name;
result.Labels = instance.Labels;
return(result);
}
public async Task <IStandardInstance> CreateInstanceAsync(IStandardInstance instance)
{
var newJiraIssue = await _issueMapper.ToNewSpecialObject(instance);
try
{
var createdIssue = await newJiraIssue.SaveChangesAsync();
try
{
if (instance.Status != null)
{
await createdIssue.WorkflowTransitionAsync(instance.Status);
}
}
catch (Exception e)
{
Debug.WriteLine("Error setting status. Value of status in instance: " + instance.Status);
Debug.WriteLine(e.StackTrace);
}
instance.Identifiers[InstanceKeyNames.JIRA_ISSUE] = new Identifiers()
{
Id = createdIssue.Key.Value,
ProjectId = createdIssue.Project,
Url = _configSettings.HomeUri + "browse/" + createdIssue.Key.Value
};
}
catch (Exception e)
{
Debug.WriteLine("Failed to save new issue...");
Debug.WriteLine(e.StackTrace);
}
return(instance);
}
public void DeleteInstanceAsync(IStandardInstance instance)
{
throw new NotImplementedException();
}
public async Task <IStandardInstance> HandleUpdate(IStandardInstance instance)
{
var handledInstance = await _resourceService.UpdateInstanceAsync(instance);
return(handledInstance);
}
public async Task HandleDeletion(IStandardInstance instance)
{
throw new NotImplementedException();
}
public async Task <string> ConsumeServiceBus1()
{
var receiver = new MessageReceiver(connectionString, QueName, ReceiveMode.ReceiveAndDelete,
RetryPolicy.NoRetry, 1);
IList <Message> messagesFromSrvcBus = await receiver.ReceiveAsync(1);
string msgContent = Encoding.UTF8.GetString(messagesFromSrvcBus[0].Body);
IStandardInstance strdMsg = JsonConvert.DeserializeObject <IStandardInstance>(msgContent);
Topic tpc = new Topic();
HttpResponseMessage response = new HttpResponseMessage();
if (strdMsg.Action == "created")
{
tpc = mapx.ConvertToTopic(strdMsg);
var values = new Dictionary <string, string>
{
{ "title", tpc.Title },
{ "qguid", tpc.QGuid },
{ "projectId", tpc.ProjectId },
{ "AuthorName", tpc.AuthorName },
{ "AuthorEmail", tpc.AuthorEmail },
{ "CreationDate", tpc.CreationDate }
};
var client = new HttpClient();
client.BaseAddress = new Uri("https://topics.quadridcm.com/api/");
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var content = new FormUrlEncodedContent(values);
response = await client.PostAsync("projects/" + tpc.ProjectId + "/topics", content);
}
else if (strdMsg.Action == "updated")
{
tpc = mapx.ConvertToTopic(strdMsg);
var values = new Dictionary <string, string>
{
{ "title", tpc.Title },
{ "qguid", tpc.QGuid },
{ "id", tpc.Id },
{ "projectId", tpc.ProjectId },
{ "AuthorName", tpc.AuthorName },
{ "AuthorEmail", tpc.AuthorEmail },
{ "CreationDate", tpc.CreationDate }
};
var client = new HttpClient();
client.BaseAddress = new Uri("https://topics.quadridcm.com/api/");
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var content = new FormUrlEncodedContent(values);
response = await client.PutAsync("projects/" + tpc.ProjectId + "/topics/" + tpc.Id, content);
}
return(response.ToString());
}
public async Task ConsumeServiceBus()
{
var managementClient = new ManagementClient(connectionString);
var queue = await managementClient.GetQueueRuntimeInfoAsync(QueName);
var x = (int)queue.MessageCount;
var receiver = new MessageReceiver(connectionString, QueName, ReceiveMode.ReceiveAndDelete,
RetryPolicy.NoRetry, x);
IList <Message> messagesFromSrvcBus = await receiver.ReceiveAsync(x);
for (var i = 0; i < x; i++)
{
string msgContent = Encoding.UTF8.GetString(messagesFromSrvcBus[i].Body);
IStandardMessage strdMsg = JsonConvert.DeserializeObject <IStandardMessage>(msgContent);
Topic tpc;
CommentEasyAccess cmtEa;
await receiver.CloseAsync();
if (strdMsg.Action == "created")
{
IStandardInstance strdInstance = JsonConvert.DeserializeObject <IStandardInstance>(msgContent);
tpc = mapx.ConvertToTopic(strdInstance);
var values = new Dictionary <string, string>
{
{ "title", tpc.Title },
{ "qguid", tpc.QGuid },
{ "projectId", tpc.ProjectId },
{ "AuthorName", tpc.AuthorName },
{ "AuthorEmail", tpc.AuthorEmail },
{ "CreationDate", tpc.CreationDate }
};
var client = new HttpClient();
client.BaseAddress = new Uri("https://topics.quadridcm.com/api/");
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var content = new FormUrlEncodedContent(values);
var response = await client.PostAsync("projects/" + tpc.ProjectId + "/topics", content);
}
else if (strdMsg.Action == "updated")
{
IStandardInstance strdInstance = JsonConvert.DeserializeObject <IStandardInstance>(msgContent);
tpc = mapx.ConvertToTopic(strdInstance);
var values = new Dictionary <string, string>
{
{ "title", tpc.Title },
{ "qguid", tpc.QGuid },
{ "id", tpc.Id },
{ "projectId", tpc.ProjectId },
{ "AuthorName", tpc.AuthorName },
{ "AuthorEmail", tpc.AuthorEmail },
{ "CreationDate", tpc.CreationDate }
};
var client = new HttpClient();
client.BaseAddress = new Uri("https://topics.quadridcm.com/api/");
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var content = new FormUrlEncodedContent(values);
var response = await client.PutAsync("projects/" + tpc.ProjectId + "/topics/" + tpc.Id, content);
}
else if (strdMsg.Action == "commented")
{
IstandardComment strdComment = JsonConvert.DeserializeObject <IstandardComment>(msgContent);
cmtEa = mapx.ConvertCommentEasyAccess(strdComment);
var values = new Dictionary <string, string>
{
{ "topicGuid", cmtEa.Id },
{ "projectId", cmtEa.ProjectId },
{ "content", cmtEa.Content },
{ "date", cmtEa.Date },
};
var client = new HttpClient();
client.BaseAddress = new Uri("https://topics.quadridcm.com/api/");
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var content = new FormUrlEncodedContent(values);
var response = await client.PostAsync("projects/" + cmtEa.ProjectId + "/topics/" + cmtEa.Id + "/comments", content);
}
}
}
public async void DeleteInstanceAsync(IStandardInstance instance)
{
await _resourceClient.RestClient.Issues.DeleteIssueAsync(instance.Identifiers[InstanceKeyNames.JIRA_ISSUE].Id);
}
