private void NewWorkItem(IIncomingEmailMessage message)
{
var workItemUpdates = new Dictionary <string, string>();
InitWorkItemFields(message, workItemUpdates);
var overrides = new OverridesExtractor(_config).GetOverrides(message);
var workItemId = _workItemManager.CreateWorkItem(workItemUpdates, overrides);
Logger.InfoFormat("Added new work item {0} for message with subject: {1} (conversation index:{2})", workItemId, message.Subject, message.ConversationIndex);
if (_config.WorkItemSettings.AttachOriginalMessage)
{
try
{
ProcessAttachments(message, workItemId);
string originalMessageFile = message.SaveToFile();
_workItemManager.AttachFiles(workItemId, new List <string> {
originalMessageFile
});
}
catch (Exception ex)
{
Logger.ErrorFormat("Exception caught while applying settings to work item {0}\n{1}", workItemId, ex);
}
}
_ackEmailHandler.SendAckEmail(message, workItemId.ToString(CultureInfo.InvariantCulture));
}
private void InitWorkItemFields(IIncomingEmailMessage message, Dictionary <string, string> workItemUpdates)
{
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
workItemUpdates["Title"] = resolver.Subject;
var rawConversationIndex = message.ConversationId;
workItemUpdates[_config.WorkItemSettings.ConversationIndexFieldName] =
rawConversationIndex.Substring(0, Math.Min(rawConversationIndex.Length, TfsTextFieldMaxLength));
foreach (var defaultFieldValue in _config.WorkItemSettings.DefaultFieldValues)
{
workItemUpdates[defaultFieldValue.Field] = resolver.Resolve(defaultFieldValue.Value);
}
string emailBodyFieldName = _config.WorkItemSettings.EmailBodyFieldName;
if (!String.IsNullOrEmpty(emailBodyFieldName))
{
if (workItemUpdates.Keys.Contains(emailBodyFieldName))
{
Logger.Warn($"Field {emailBodyFieldName} is defined for mapping in {nameof(_config.WorkItemSettings.EmailBodyFieldName)} for mapping. The DefaultValueDefinition entry will be ignored.");
}
workItemUpdates[emailBodyFieldName] = MailHeaderExtractor.GetHtmlBody(_config, message, resolver.HtmlMessageBody);
}
}
private string GetMessageFullText(IIncomingEmailMessage message)
{
var sb = new StringBuilder();
sb.AppendLine(message.Subject).AppendLine(message.PlainTextBody);
return(sb.ToString());
}
public void ModifyWorkItem(int workItemId, IIncomingEmailMessage message, Dictionary <string, string> values)
{
if (ThrowOnModifyBug != null)
{
throw ThrowOnModifyBug;
}
if (!Bugs.ContainsKey(workItemId))
{
Logger.WarnFormat("Trying to modify non-existing bug {0}. Initializing with no field values", workItemId);
Bugs[workItemId] = new Dictionary <string, string>();
}
var bugEntry = Bugs[workItemId];
foreach (var key in values.Keys)
{
bugEntry[key] = values[key];
}
if (!bugEntry.ContainsKey(HistoryField))
{
bugEntry[HistoryField] = "";
}
bugEntry[HistoryField] += message.GetLastMessageText();
}
private void NewWorkItem(IIncomingEmailMessage message)
{
var workItemUpdates = new Dictionary <string, string>();
InitWorkItemFields(message, workItemUpdates);
var workItemId = _workItemManager.CreateWorkItem(workItemUpdates);
Logger.InfoFormat("Added new work item {0} for message with subject: {1} (conversation index:{2})",
workItemId, message.Subject, message.ConversationId);
try
{
// Since the work item *has* been created, failures in this stage are not treated as critical
var overrides = new OverridesExtractor(_config).GetOverrides(message);
TryApplyFieldOverrides(overrides, workItemId);
ProcessAttachments(message, workItemId);
if (_config.WorkItemSettings.AttachOriginalMessage)
{
AttachMessageToWorkItem(message, workItemId, "OriginalMessage");
}
}
catch (Exception ex)
{
Logger.ErrorFormat("Exception caught while applying settings to work item {0}\n{1}", workItemId, ex);
}
var workItem = _workItemManager.GetWorkItemFields(workItemId);
_ackEmailHandler.SendAckEmail(message, workItem);
}
private void UpdateWorkItem(IIncomingEmailMessage message, int workItemId)
{
Logger.InfoFormat("Modifying work item {0} subject: {1}", workItemId, message.Subject);
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
var workItemUpdates = new Dictionary <string, string>();
if (_config.WorkItemSettings.OverrideChangedBy)
{
workItemUpdates["Changed By"] = resolver.Sender;
}
if (_config.WorkItemSettings.ApplyOverridesDuringUpdate)
{
var extractor = new OverridesExtractor(_config);
var overrides = extractor.GetOverrides(message.GetLastMessageText());
Logger.DebugFormat("Found {0} overrides for update message", overrides.Count);
overrides.ToList().ForEach(x => workItemUpdates[x.Key] = x.Value);
}
// Construct the text to be appended
_workItemManager.ModifyWorkItem(workItemId, message.GetLastMessageText(), workItemUpdates);
ProcessAttachments(message, workItemId);
if (_config.WorkItemSettings.AttachUpdateMessages)
{
AttachMessageToWorkItem(message, workItemId, "ReplyMessage");
}
}
public OverridesExtractor(IIncomingEmailMessage message, Config.InstanceConfig config)
{
_message = message;
_config = config;
InitDateBasedResolvers();
}
private void ProcessAttachments(IIncomingEmailMessage message, int workItemId)
{
var attachmentFiles = SaveAttachments(message);
_workItemManager.AttachFiles(workItemId, (from object file in attachmentFiles select file.ToString()).ToList());
attachmentFiles.Delete();
}
private void NewWorkItem(IIncomingEmailMessage message)
{
var workItemUpdates = new Dictionary <string, string>();
InitWorkItemFields(message, workItemUpdates);
var workItemId = _workItemManager.CreateWorkItem(workItemUpdates);
Logger.InfoFormat("Added new work item {0} for message with subject: {1} (conversation index:{2})",
workItemId, message.Subject, message.ConversationIndex);
try
{
// Since the work item *has* been created, failures in this stage are not treated as critical
TryApplyFieldOverrides(message, workItemId);
ProcessAttachments(message, workItemId);
if (_config.WorkItemSettings.AttachOriginalMessage)
{
string originalMessageFile = message.SaveToFile();
_workItemManager.AttachFiles(workItemId, new List <string> {
originalMessageFile
});
}
}
catch (Exception ex)
{
Logger.ErrorFormat("Exception caught while applying settings to work item {0}\n{1}", workItemId, ex);
}
_ackEmailHandler.SendAckEmail(message, workItemId.ToString(CultureInfo.InvariantCulture));
}
private void ProcessAttachments(IIncomingEmailMessage message, int workItemId, bool convertInlineAttachments)
{
var fileList = SaveAttachments(message);
_workItemManager.AttachAndInlineFiles(workItemId, fileList);
fileList.ToList().ForEach(x => File.Delete(x.Item1));
}
private void NewWorkItem(IIncomingEmailMessage message)
{
var workItemUpdates = new Dictionary<string, string>();
InitWorkItemFields(message, workItemUpdates);
var workItemId = _workItemManager.CreateWorkItem(workItemUpdates);
Logger.InfoFormat("Added new work item {0} for message with subject: {1} (conversation index:{2})",
workItemId, message.Subject, message.ConversationIndex);
try
{
// Since the work item *has* been created, failures in this stage are not treated as critical
var overrides = new OverridesExtractor(_config).GetOverrides(message);
TryApplyFieldOverrides(overrides, workItemId);
ProcessAttachments(message, workItemId);
if (_config.WorkItemSettings.AttachOriginalMessage)
{
AttachMessageToWorkItem(message, workItemId, "OriginalMessage");
}
}
catch (Exception ex)
{
Logger.ErrorFormat("Exception caught while applying settings to work item {0}\n{1}", workItemId, ex);
}
_ackEmailHandler.SendAckEmail(message, workItemId.ToString(CultureInfo.InvariantCulture));
}
/// <param name="workItemId">The ID of the work item to modify </param>
/// <param name="message">Messsage to get the comment to add to description/history</param>
/// <param name="values">List of fields to change</param>
public void ModifyWorkItem(int workItemId, IIncomingEmailMessage message, Dictionary <string, string> values)
{
if (workItemId <= 0)
{
return;
}
if (_config.WorkItemSettings.UseWholeEmailBodyInHistory)
{
// just remember changes and apply them later in the AttachAndInlineFiles method
this.AddOutstandingModifyWorkItem(workItemId, MailHeaderExtractor.GetHtmlBody(_config, message, message.HtmlBody), values);
return;
}
var workItem = _tfsStore.GetWorkItem(workItemId);
workItem.Open();
string comment = message.GetLastMessageText();
workItem.History = comment.Replace("\n", "<br>");
foreach (var key in values.Keys)
{
TryApplyFieldValue(workItem, key, values[key]);
}
ValidateAndSaveWorkItem(workItem);
workItem.Save();
}
private IEnumerable<KeyValuePair<string, string>> GetRecipientOverrides(IIncomingEmailMessage message)
{
var overrides = new List<KeyValuePair<string, string>>();
overrides.AddRange(message.CcAddresses.SelectMany(ExtractRecipientOverrides));
overrides.AddRange(message.ToAddresses.SelectMany(ExtractRecipientOverrides));
return overrides;
}
private IEnumerable <KeyValuePair <string, string> > GetRecipientOverrides(IIncomingEmailMessage message)
{
var overrides = new List <KeyValuePair <string, string> >();
overrides.AddRange(message.CcAddresses.SelectMany(ExtractRecipientOverrides));
overrides.AddRange(message.ToAddresses.SelectMany(ExtractRecipientOverrides));
return(overrides);
}
public Dictionary<string, string> GetOverrides(IIncomingEmailMessage message)
{
var result = new Dictionary<string, string>();
AddToDictionary(GetRecipientOverrides(message), result);
AddToDictionary(GetDatebasedOverrides(), result);
AddToDictionary(GetMnemonicOverrides(GetMessageFullText(message)), result);
AddToDictionary(GetExplicitOverrides(GetMessageFullText(message)), result);
return result;
}
public Dictionary <string, string> GetOverrides(IIncomingEmailMessage message)
{
var result = new Dictionary <string, string>();
AddToDictionary(GetRecipientOverrides(message), result);
AddToDictionary(GetDatebasedOverrides(), result);
AddToDictionary(GetMnemonicOverrides(GetMessageFullText(message)), result);
AddToDictionary(GetExplicitOverrides(GetMessageFullText(message)), result);
return(result);
}
private string GetSenderAlias(IIncomingEmailMessage message)
{
var resolvedName = message.SenderAlias;
if (!string.IsNullOrEmpty(resolvedName))
{
Logger.InfoFormat("Alias '{0}', resolved to {1}", message.SenderAlias, resolvedName);
return(resolvedName);
}
return(string.Empty);
}
/// <summary>
/// If a work item already exists for this message, returns its ID. Otherwise, returns null.
/// </summary>
/// <param name="message">The email message for which we want to find the work item ID</param>
/// <returns></returns>
public int? GetWorkItemId(IIncomingEmailMessage message)
{
var appendOnlyId = IsAppendOnlyMessage(message);
if (appendOnlyId.HasValue)
{
Logger.InfoFormat("Append-Only message. Work item ID is {0}", appendOnlyId);
return appendOnlyId.Value;
}
// Just a standard conversation - look up the cache based on the conversation ID
return GetWorkItemIdFromConversationId(message.ConversationIndex, _workItemsCache);
}
public void ProcessInboxMessage(IIncomingEmailMessage message)
{
var workItemId = _messageToWorkItemMapper.GetWorkItemId(message);
if (!workItemId.HasValue) // thread not found, new work item
{
NewWorkItem(message);
return;
}
UpdateWorkItem(message, workItemId.Value);
}
public void ProcessInboxMessage(IIncomingEmailMessage message)
{
var workItemId = _messageToWorkItemMapper.GetWorkItemId(message);
if (!workItemId.HasValue) // thread not found, new work item
{
NewWorkItem(message);
return;
}
UpdateWorkItem(message, workItemId.Value);
}
public IncomingEmailMessageMock AddReply(IIncomingEmailMessage message, string replyText)
{
// Reply body contains the reply text, then a message separator, then the previous message's full text
var bodyBuilder = new StringBuilder(replyText);
bodyBuilder.AppendLine(RandomDataHelper.GetRandomMessageSeparator(_rand.Next()));
bodyBuilder.AppendLine(message.PlainTextBody);
var newMessage = AddMessage("RE: " + message.Subject, bodyBuilder.ToString());
newMessage.SentOn = message.SentOn.AddSeconds(1);
newMessage.ConversationIndex = GenerateReplyIndex(message.ConversationIndex);
return newMessage;
}
/// <summary>
/// If a work item already exists for this message, returns its ID. Otherwise, returns null.
/// </summary>
/// <param name="message">The email message for which we want to find the work item ID</param>
/// <returns></returns>
public int?GetWorkItemId(IIncomingEmailMessage message)
{
var appendOnlyId = IsAppendOnlyMessage(message);
if (appendOnlyId.HasValue)
{
Logger.InfoFormat("Append-Only message. Work item ID is {0}", appendOnlyId);
return(appendOnlyId.Value);
}
// Just a standard conversation - look up the cache based on the conversation ID (or guid)
return(GetWorkItemIdFromConversationId(message.ConversationId, _workItemsCache));
}
public static string GetLastMessageText(IIncomingEmailMessage message)
{
var lastMessage = new StringBuilder();
lastMessage.Append(message.PlainTextBody);
var next = GetReplySeperatorIndex(lastMessage.ToString());
if (next > 0)
{
lastMessage.Remove(next, lastMessage.Length - next);
}
return lastMessage.ToString();
}
private void AppendToWorkItem(IIncomingEmailMessage message, int workItemId)
{
Logger.InfoFormat("Modifying work item {0} subject: {1}", workItemId, message.Subject);
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
var workItemUpdates = new Dictionary <string, string> {
{ "Changed By", resolver.Sender }
};
// Construct the text to be appended
_workItemManager.ModifyWorkItem(workItemId, message.GetLastMessageText(), workItemUpdates);
ProcessAttachments(message, workItemId);
}
private string GetSender(IIncomingEmailMessage message)
{
var resolvedName = _resolver.Resolve(message.SenderAlias, message.SenderName);
if (!string.IsNullOrEmpty(resolvedName))
{
Logger.InfoFormat("Alias '{0}', resolved to {1}", message.SenderAlias, resolvedName);
return(resolvedName);
}
// Name resolution was not successful, return the display name
Logger.WarnFormat("Name resolution failed for sender alias '{0}'. Returning display name.",
message.SenderAlias);
return(message.SenderName);
}
private static string GetLastMessageText_PlainText(IIncomingEmailMessage message)
{
var lastMessage = new StringBuilder();
lastMessage.Append(message.PlainTextBody);
var next = GetReplySeperatorIndex(lastMessage.ToString());
if (next > 0)
{
lastMessage.Remove(next, lastMessage.Length - next);
}
return(lastMessage.ToString());
}
private void AttachMessageToWorkItem(IIncomingEmailMessage message, int workItemId, string prefix)
{
using (var tfc = new TempFileCollection())
{
var fileName = string.Format("{0}_{1}_{2}.eml", prefix, DateTime.Now.ToString("yyyyMMdd_hhmmss"), new Random().Next());
var filePath = Path.Combine(Path.GetTempPath(), fileName);
message.SaveToFile(filePath);
// Remove the file once we're done attaching it
tfc.AddFile(filePath, false);
_workItemManager.AttachFiles(workItemId, new List<string> { filePath });
}
}
private void InitWorkItemFields(IIncomingEmailMessage message, Dictionary <string, string> workItemUpdates)
{
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
workItemUpdates["Title"] = resolver.Subject;
var rawConversationIndex = message.ConversationId;
workItemUpdates[_config.WorkItemSettings.ConversationIndexFieldName] =
rawConversationIndex.Substring(0, Math.Min(rawConversationIndex.Length, TfsTextFieldMaxLength));
foreach (var defaultFieldValue in _config.WorkItemSettings.DefaultFieldValues)
{
workItemUpdates[defaultFieldValue.Field] = resolver.Resolve(defaultFieldValue.Value);
}
}
public IncomingEmailMessageMock AddReply(IIncomingEmailMessage message, string replyText)
{
// Reply body contains the reply text, then a message separator, then the previous message's full text
var bodyBuilder = new StringBuilder(replyText);
bodyBuilder.AppendLine(RandomDataHelper.GetRandomMessageSeparator(_rand.Next()));
bodyBuilder.AppendLine(message.PlainTextBody);
var newMessage = AddMessage("RE: " + message.Subject, bodyBuilder.ToString());
newMessage.SentOn = message.SentOn.AddSeconds(1);
newMessage.ConversationId = GenerateReplyIndex(message.ConversationId);
return(newMessage);
}
/// <summary>
/// Send mail announcing receipt of new ticket
/// </summary>
public void SendAckEmail(IIncomingEmailMessage originalMessage, string workItemId)
{
// Don't send ack emails if it's disabled in configuration
if (!_config.EmailSettings.SendAckEmails)
{
Logger.DebugFormat("Ack emails disabled in configuration - skipping");
return;
}
var ewsMessage = originalMessage as EWSIncomingMessage;
if (ewsMessage != null)
{
HandleEWSMessage(ewsMessage, workItemId);
}
}
private string GetSender(IIncomingEmailMessage message)
{
var resolvedName = _resolver.Resolve(message.SenderAlias, message.SenderName);
if (!string.IsNullOrEmpty(resolvedName))
{
Logger.InfoFormat("Alias '{0}', resolved to {1}", message.SenderAlias, resolvedName);
return resolvedName;
}
// Name resolution was not successful, return the display name
Logger.WarnFormat("Name resolution failed for sender alias '{0}'. Returning display name.",
message.SenderAlias);
return message.SenderName;
}
/// <summary>
/// Take attachments from the current mail message and put them in a work item
/// </summary>
/// <param name="message"></param>
private static MessageAttachmentCollection SaveAttachments(IIncomingEmailMessage message)
{
var result = new MessageAttachmentCollection();
foreach (var attachment in message.Attachments)
{
var filename = attachment.SaveAttachmentToFile();
if (filename != null)
{
result.Add(filename, attachment.ContentId);
Logger.InfoFormat("Attachment saved to file {0}", filename);
}
}
return(result);
}
/// <summary>
/// Take attachments from the current mail message and put them in a work item
/// </summary>
/// <param name="message"></param>
private static TempFileCollection SaveAttachments(IIncomingEmailMessage message)
{
var attachmentFiles = new TempFileCollection();
foreach (var attachment in message.Attachments)
{
var filename = attachment.SaveAttachmentToFile();
if (filename != null)
{
attachmentFiles.AddFile(filename, false);
Logger.InfoFormat("Attachment saved to file {0}", filename);
}
}
return(attachmentFiles);
}
/// <summary>
/// Take attachments from the current mail message and put them in a work item
/// </summary>
/// <param name="message"></param>
private static TempFileCollection SaveAttachments(IIncomingEmailMessage message)
{
var attachmentFiles = new TempFileCollection();
foreach (var attachment in message.Attachments)
{
var filename = attachment.SaveAttachmentToFile();
if (filename != null)
{
attachmentFiles.AddFile(filename, false);
Logger.InfoFormat("Attachment saved to file {0}", filename);
}
}
return attachmentFiles;
}
/// <summary>
/// Send mail announcing receipt of new ticket
/// </summary>
public void SendAckEmail(IIncomingEmailMessage originalMessage, IWorkItemFields workItemFields)
{
// Don't send ack emails if it's disabled in configuration
if (!_config.EmailSettings.SendAckEmails)
{
Logger.DebugFormat("Ack emails disabled in configuration - skipping");
return;
}
var ewsMessage = originalMessage as EWSIncomingMessage;
if (ewsMessage != null)
{
HandleEWSMessage(ewsMessage, workItemFields);
}
}
public static string GetHtmlBody(Config.InstanceConfig config, IIncomingEmailMessage message, string htmlBody)
{
string newHtmlBody = "";
if (config.WorkItemSettings.AddEmailHeaderToMessageDescription)
{
var extractor = new MailHeaderExtractor(message);
newHtmlBody = Regex.Replace(htmlBody, @"(<body.*?>)", "$1" + extractor.GetHeaderHtml());
}
else
{
newHtmlBody = htmlBody;
}
return(newHtmlBody);
}
/// <summary>
/// Send mail announcing receipt of new ticket
/// </summary>
public void SendAckEmail(IIncomingEmailMessage originalMessage, string bugId)
{
// Don't send ack emails if it's disabled in configuration or if we're in simulation mode
if (!_config.EmailSettings.SendAckEmails || _config.TfsServerConfig.SimulationMode)
{
Logger.DebugFormat("Ack emails disabled in configuration - skipping");
return;
}
var ewsMessage = originalMessage as EWSIncomingMessage;
if (ewsMessage != null)
{
HandleEWSMessage(ewsMessage, bugId);
}
}
private int?IsAppendOnlyMessage(IIncomingEmailMessage message)
{
var workItemId = GetWorkItemIdFromText(message.Subject, _appendOnlyEmailTitleRegex, "id");
if (!workItemId.HasValue)
{
workItemId = GetWorkItemIdFromText(message.PlainTextBody, _appendOnlyEmailBodyRegex, "id");
}
if (!workItemId.HasValue)
{
return(null);
}
return(workItemId);
}
private int? IsAppendOnlyMessage(IIncomingEmailMessage message)
{
var workItemId = GetWorkItemIdFromText(message.Subject, _appendOnlyEmailTitleRegex, "id");
if (!workItemId.HasValue)
{
workItemId = GetWorkItemIdFromText(message.PlainTextBody, _appendOnlyEmailBodyRegex, "id");
}
if (!workItemId.HasValue)
{
return null;
}
return workItemId;
}
private void AttachMessageToWorkItem(IIncomingEmailMessage message, int workItemId, string prefix)
{
using (var tfc = new TempFileCollection())
{
var fileName = string.Format("{0}_{1}_{2}.eml", prefix, DateTime.Now.ToString("yyyyMMdd_hhmmss"), new Random().Next());
var filePath = Path.Combine(Path.GetTempPath(), fileName);
message.SaveToFile(filePath);
// Remove the file once we're done attaching it
tfc.AddFile(filePath, false);
_workItemManager.AttachFiles(workItemId, new List <string> {
filePath
});
}
}
public SpecialValueResolver(IIncomingEmailMessage message, INameResolver resolver)
{
_resolver = resolver;
_valueResolutionMap = new Dictionary<string, string>();
_valueResolutionMap[SubjectKeyword] = GetValidSubject(message);
_valueResolutionMap[SenderKeyword] = GetSender(message);
_valueResolutionMap[MessageBodyKeyword] = TextUtils.FixLineBreaks(message.PlainTextBody);
_valueResolutionMap[MessageBodyWithSenderKeyword] =
String.Format("{0}\n\nCreated by: {1} ({2})",
_valueResolutionMap[MessageBodyKeyword],
message.SenderName,
message.SenderAddress);
_valueResolutionMap[RawMessageBodyKeyword] = TextUtils.FixLineBreaks(message.RawBody);
_valueResolutionMap[NowKeyword] = DateTime.Now.ToString("g");
_valueResolutionMap[TodayKeyword] = DateTime.Now.ToString("d");
_valueResolutionMap[LocationKeyword] = message.Location;
_valueResolutionMap[StartTimeKeyword] = GetValidTimeString(message.StartTime);
_valueResolutionMap[EndTimeKeyword] = GetValidTimeString(message.EndTime);
}
public SpecialValueResolver(IIncomingEmailMessage message, INameResolver resolver)
{
_resolver = resolver;
_valueResolutionMap = new Dictionary <string, string>();
_valueResolutionMap[SubjectKeyword] = GetValidSubject(message);
_valueResolutionMap[SenderKeyword] = GetSender(message);
_valueResolutionMap[MessageBodyKeyword] = TextUtils.FixLineBreaks(message.PlainTextBody);
_valueResolutionMap[MessageBodyWithSenderKeyword] =
String.Format("{0}\nCreated by: {1}({2})",
_valueResolutionMap[MessageBodyKeyword],
message.SenderName,
message.SenderAddress);
_valueResolutionMap[RawMessageBodyKeyword] = TextUtils.FixLineBreaks(message.RawBody);
_valueResolutionMap[NowKeyword] = DateTime.Now.ToString("g");
_valueResolutionMap[TodayKeyword] = DateTime.Now.ToString("d");
_valueResolutionMap[LocationKeyword] = message.Location;
_valueResolutionMap[StartTimeKeyword] = GetValidTimeString(message.StartTime);
_valueResolutionMap[EndTimeKeyword] = GetValidTimeString(message.EndTime);
}
private void UpdateWorkItem(IIncomingEmailMessage message, int workItemId)
{
Logger.InfoFormat("Modifying work item {0} subject: {1}", workItemId, message.Subject);
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
var workItemUpdates = new Dictionary <string, string>();
if (_config.WorkItemSettings.OverrideChangedBy)
{
workItemUpdates["Changed By"] = resolver.Sender;
}
bool isHtmlEnabled = _config.WorkItemSettings.EnableExperimentalHtmlFeatures;
bool commentIsHtml = message.IsHtmlBody && isHtmlEnabled;
string lastMessageText = message.GetLastMessageText(isHtmlEnabled);
if (_config.WorkItemSettings.ApplyOverridesDuringUpdate)
{
// OverrideExtractor can't currently handle HTML input, so we need to make sure we pass it the plain text version
string lastMessagePlainText = commentIsHtml
? message.GetLastMessageText(enableExperimentalHtmlFeatures: false)
: lastMessageText;
var extractor = new OverridesExtractor(_config);
var overrides = extractor.GetOverrides(lastMessagePlainText);
Logger.DebugFormat("Found {0} overrides for update message", overrides.Count);
overrides.ToList().ForEach(x => workItemUpdates[x.Key] = x.Value);
}
using (var attachments = SaveAttachments(message))
{
_workItemManager.ModifyWorkItem(workItemId, lastMessageText, commentIsHtml, workItemUpdates, attachments);
}
if (_config.WorkItemSettings.AttachUpdateMessages)
{
AttachMessageToWorkItem(message, workItemId, "ReplyMessage");
}
}
private static bool ShouldConsiderMessage(IIncomingEmailMessage message, string[] recipients)
{
if (message == null)
{
return false;
}
// If no recipients were mentioned, it means process all incoming emails
if (!recipients.Any())
{
return true;
}
// If the recipient is in either the To or CC lines, then this message should be considered
return recipients.Any(recipient =>
EmailAddressesMatch(message.ToAddresses, recipient) ||
EmailAddressesMatch(message.ToNames, recipient) ||
EmailAddressesMatch(message.CcAddresses, recipient) ||
EmailAddressesMatch(message.CcNames, recipient));
}
IIncomingEmailMessage[] CreateMessages(
int numMessages,
string subjectBase,
DateTime startTime,
TimeSpan intervalBetweenMessages)
{
var result = new IIncomingEmailMessage[numMessages];
var receivedTime = startTime;
for (var i = 0; i < numMessages; ++i, receivedTime += intervalBetweenMessages)
{
var message = new IncomingEmailMessageMock
{
Subject = string.Format("{0}_{1}", subjectBase, i),
ReceivedOn = receivedTime
};
result[i] = message;
}
return result;
}
private void InitWorkItemFields(IIncomingEmailMessage message, Dictionary<string, string> workItemUpdates)
{
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
workItemUpdates["Title"] = resolver.Subject;
var rawConversationIndex = message.ConversationIndex;
workItemUpdates[_config.WorkItemSettings.ConversationIndexFieldName] =
rawConversationIndex.Substring(0, Math.Min(rawConversationIndex.Length, TfsTextFieldMaxLength));
foreach (var defaultFieldValue in _config.WorkItemSettings.DefaultFieldValues)
{
workItemUpdates[defaultFieldValue.Field] = resolver.Resolve(defaultFieldValue.Value);
}
}
private void InitWorkItemFields(IIncomingEmailMessage message, Dictionary<string, string> workItemUpdates)
{
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
//workItemUpdates["Title"] = resolver.Subject;
workItemUpdates[FieldNames.Incident.CreatedBy] = resolver.SenderAlias;
workItemUpdates[FieldNames.Incident.Title] = resolver.Subject;
workItemUpdates[FieldNames.Incident.Description] = resolver.MessageBody;
workItemUpdates[FieldNames.Incident.CreateDate] = message.SentOn.ToUniversalTime().ToString();
var rawConversationIndex = message.ConversationIndex;
workItemUpdates[_config.WorkItemSettings.ConversationIndexFieldName] = rawConversationIndex.Substring(
0,
Math.Min(rawConversationIndex.Length, TfsTextFieldMaxLength));
foreach (var defaultFieldValue in _config.WorkItemSettings.DefaultFieldValues)
{
workItemUpdates[defaultFieldValue.Field] = resolver.Resolve(defaultFieldValue.Value);
}
}
public void OnProcessingFinished(IIncomingEmailMessage message, bool successful)
{
_postProcessor.Process((EWSIncomingMessage)message, successful);
}
private static string GetValidSubject(IIncomingEmailMessage message)
{
return !string.IsNullOrEmpty(message.ConversationTopic) ? message.ConversationTopic : "NO SUBJECT";
}
private string GetSenderAlias(IIncomingEmailMessage message)
{
var resolvedName = message.SenderAlias;
if (!string.IsNullOrEmpty(resolvedName))
{
Logger.InfoFormat("Alias '{0}', resolved to {1}", message.SenderAlias, resolvedName);
return resolvedName;
}
return string.Empty;
}
private void UpdateWorkItem(IIncomingEmailMessage message, int workItemId)
{
Logger.InfoFormat("Modifying work item {0} subject: {1}", workItemId, message.Subject);
var resolver = new SpecialValueResolver(message, _workItemManager.GetNameResolver());
var workItemUpdates = new Dictionary<string, string>();
if (_config.WorkItemSettings.OverrideChangedBy)
{
workItemUpdates["Changed By"] = resolver.Sender;
}
if (_config.WorkItemSettings.ApplyOverridesDuringUpdate)
{
var extractor = new OverridesExtractor(_config);
var overrides = extractor.GetOverrides(message.GetLastMessageText());
Logger.DebugFormat("Found {0} overrides for update message", overrides.Count);
overrides.ToList().ForEach(x => workItemUpdates[x.Key] = x.Value);
}
// Construct the text to be appended
_workItemManager.ModifyWorkItem(workItemId, message.GetLastMessageText(), workItemUpdates);
ProcessAttachments(message, workItemId);
if (_config.WorkItemSettings.AttachUpdateMessages)
{
AttachMessageToWorkItem(message, workItemId, "ReplyMessage");
}
}
private void ProcessAttachments(IIncomingEmailMessage message, int workItemId)
{
var attachmentFiles = SaveAttachments(message);
_workItemManager.AttachFiles(workItemId, (from object file in attachmentFiles select file.ToString()).ToList());
attachmentFiles.Delete();
}
private string GetMessageFullText(IIncomingEmailMessage message)
{
var sb = new StringBuilder();
sb.AppendLine(message.Subject).AppendLine(message.PlainTextBody);
return sb.ToString();
}
private void NewWorkItem(IIncomingEmailMessage message)
{
var workItemUpdates = new Dictionary<string, string>();
InitWorkItemFields(message, workItemUpdates);
var overrides = new OverridesExtractor(_config).GetOverrides(message);
var workItemId = _workItemManager.CreateWorkItem(workItemUpdates, overrides);
Logger.InfoFormat("Added new work item {0} for message with subject: {1} (conversation index:{2})", workItemId, message.Subject, message.ConversationIndex);
if (_config.WorkItemSettings.AttachOriginalMessage)
{
try
{
ProcessAttachments(message, workItemId);
string originalMessageFile = message.SaveToFile();
_workItemManager.AttachFiles(workItemId, new List<string> { originalMessageFile });
}
catch (Exception ex)
{
Logger.ErrorFormat("Exception caught while applying settings to work item {0}\n{1}", workItemId, ex);
}
}
_ackEmailHandler.SendAckEmail(message, workItemId.ToString(CultureInfo.InvariantCulture));
}
public void OnProcessingFinished(IIncomingEmailMessage message, bool successful)
{
_postProcessedMessages.Add(message);
}
