public FolderId GetOutlookProjectPath(Entity.Store store)
{
//find the program folder first then search it for the project folder
var parentView = new FolderView(int.MaxValue);
parentView.PropertySet = new PropertySet(BasePropertySet.IdOnly, FolderSchema.DisplayName);
var programNumber = Configuration.ConfigHandler.InstanceOf.ProgramMappings.Where(
x => x.Value.Equals(store.Program))
.Select(y => y.Key).Distinct();
var taskResult = new System.Collections.Generic.List <System.Threading.Tasks.Task <FolderId> >();
foreach (var element in programNumber)
{
var filter = new SearchFilter.ContainsSubstring(FolderSchema.DisplayName, element.ToString("D2") + " ");
var result = this.GetEmailService.FindFolders(WellKnownFolderName.PublicFoldersRoot, filter, parentView);
var programFolder = result.Where(y => typeof(Microsoft.Exchange.WebServices.Data.ContactsFolder) != y.GetType());
taskResult.Add(this.FindProjectPath(programFolder.First(), 0, 255, "(" + store.ProjectNumber.ToString("D7") + ")", 0));
}
var asyncResults = System.Threading.Tasks.Task.WhenAll(taskResult);
var folders = asyncResults.Result;
return(folders.Single(x => x != null));
}
public Enum.QuestionTypes TryCategorizationFromText(string guess, Entity.Store store, out string category)
{
var searchString = new System.Text.StringBuilder(guess);
searchString.AppendFormat(" {0}-{1}", store.Number, store.Sequence);
return(this.TryCategorizationFromString(searchString.ToString(), out category, out store));
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="store"></param>
/// <param name="category"></param>
/// <returns>true if we were able to set attachments; false otherwise</returns>
public bool TryGetAndAttachDocuments(EmailMessage message, Entity.Store store, string category)
{
var regex = new System.Text.RegularExpressions.Regex(@"RFI:\s(?<rfi>\d+)\b");
var match = regex.Match(category);
var group = match.Groups;
var sid = group["rfi"].Value;
int rfiNumber;
if (int.TryParse(sid, out rfiNumber))
{
var creds = Configuration.ConfigHandler.InstanceOf.GetCredentials;
var crawler = new EvocoWebCrawler.HttpClient(creds);
System.IO.Stream docStream;
if (crawler.TryNavigateStoreRfi(store.Number, store.Sequence, rfiNumber, out docStream))
{
var rfiAttachments = crawler.GetHttpFileAttachment(docStream);
int count = 1;
foreach (var item in rfiAttachments)
{
//we're going to rename the rfi attachments to match the RHA convention:
// {storenumber}_RFI {rfinumber,D3}_Attachment {ordinal,D2}.{extension}
// example: 6188_RFI 044_Attachment 01.pdf
var parser = new Parser();
var extension = parser.GetAttachmentExtension(item.Key);
var name = string.Format("{0}_RFI {1}_Attachment {2}{3}", store.Number.ToString(), rfiNumber.ToString("D3"), count.ToString("D2"), extension);
message.Attachments.AddFileAttachment(name, item.Value);
Logger.LoggerAsync.InstanceOf.GeneralLogger.Info("Found and attached file: ", name);
count++;
}
return(true);
}
}
return(false);
}
private bool MoveEmailsToFolder(FindItemsResults <Item> items, Entity.Store store)
{
var folderId = this.GetOutlookProjectPath(store);
var rfiFolderId = this.GetProjectRfiFolder(folderId);
var success = true;
foreach (var item in items)
{
var message = Microsoft.Exchange.WebServices.Data.Item.Bind(this.GetEmailService,
item.Id,
EmailProperties
);
if (message.HasAttachments)
{
success = this.MoveAttachmentsToFolder(message, store);
Logger.LoggerAsync.InstanceOf.GeneralLogger.Info("Moved attachments to folder for project {0} {1}", store.ProjectNumber, store.City);
}
if (success)
{
try {
if (message.Flag.FlagStatus == ItemFlagStatus.Flagged)
{
message.Flag.FlagStatus = ItemFlagStatus.Complete;
}
message.Update(ConflictResolutionMode.AlwaysOverwrite);
var newItem = message.Move(rfiFolderId);
success = true;
Logger.LoggerAsync.InstanceOf.GeneralLogger.Info("Moved email to folder for project {0} {1}", store.ProjectNumber, store.City);
} catch (Exception x) {
success = false;
Logger.LoggerAsync.InstanceOf.GeneralLogger.Error("Moving email to folder failed: {0}", x);
}
}
}
return(success);
}
public bool MoveEmailItemInOutlook(EmailMessage message, Entity.Store store)
{
//var forwardEmail = this.CreateDraftEmail(message, store);
Item movedMessage;
switch (store.Program)
{
case Enum.ProgramTypes.None:
case Enum.ProgramTypes.Generic:
break;
case Enum.ProgramTypes.NewStores:
movedMessage = message.Move(this.rfiNewStoresFolder);
//this.ArchiveAnsweredRfi(movedMessage, store);
break;
case Enum.ProgramTypes.TakeOvers:
case Enum.ProgramTypes.Resturants:
case Enum.ProgramTypes.Expansions:
case Enum.ProgramTypes.Special:
case Enum.ProgramTypes.DallasCommunityCollege:
case Enum.ProgramTypes.ABRHoldings:
case Enum.ProgramTypes.Express:
movedMessage = message.Move(this.rfiExistingStoresFolder);
//this.ArchiveAnsweredRfi(movedMessage, store);
break;
case Enum.ProgramTypes.FuelStations:
case Enum.ProgramTypes.Remodels:
movedMessage = message.Move(this.rfiRemodelFolder);
break;
default:
throw new Exception("Invalid value for ProgramTypes");
}
return(false);
}
public string GetFileServerProjectPath(Entity.Store store)
{
var programMappedPath = Configuration.ConfigHandler.InstanceOf.FileServerMappings.Where(
x => x.Key == store.Program);
string result = "";
foreach (var pair in programMappedPath)
{
var path = new System.IO.DirectoryInfo(pair.Value);
Logger.LoggerAsync.InstanceOf.GeneralLogger.Info("Preparing to enumerate directories under {0} looking for {1}", path.FullName, store.ProjectNumber);
try {
var subFolders = path.EnumerateDirectories("*" + store.ProjectNumber + "*", System.IO.SearchOption.TopDirectoryOnly);
if (subFolders.Count() > 1)
{
foreach (var folder in subFolders)
{
result = this.GetFileServerProjectPath(store);
}
}
else if (subFolders.Count() < 1)
{
continue;
}
else
{
var folder = subFolders.First();
var rfi = this.FindFileServerRfi(folder);
result = rfi.FullName;
}
} catch (Exception x) {
Logger.LoggerAsync.InstanceOf.GeneralLogger.Error(x);
throw x;
}
}
this.path = result;
return(result);
}
public ResponseMessage CreateDraftEmail(EmailMessage originalEmail, Entity.Store store)
{
var forwardEmail = originalEmail.CreateForward();
try {
var contacts = connector.GetProjectContacts(store);
foreach (var contact in contacts)
{
forwardEmail.ToRecipients.Add(contact.Email);
}
} catch (ArgumentNullException ex) {
}
var body = @"Please see request for information below and respond as soon as possible.
PLEASE DO NOT MODIFY SUBJECT LINE
";
forwardEmail.BodyPrefix = body;
return(forwardEmail);
}
private bool MoveAttachmentsToFolder(Microsoft.Exchange.WebServices.Data.Item item, Entity.Store store)
{
var fileHandler = new Utilities.FileHandler(store);
if (item.HasAttachments)
{
var success = fileHandler.SaveAttachmentsToFolder(item.Attachments);
if (success)
{
item.Attachments.Clear();
item.Update(ConflictResolutionMode.AlwaysOverwrite);
}
}
return(false);
}
public bool ArchiveAnsweredRfi(Microsoft.Exchange.WebServices.Data.Item email, Entity.Store store)
{
var message = Microsoft.Exchange.WebServices.Data.EmailMessage.Bind(this.GetEmailService,
email.Id,
EmailProperties
);
var subject = message.Subject;
var parser = new Parser();
var success = false;
if (parser.IsAnsweredQuestion(subject))
{
if (message.Sender.Name == "Amy Mills" && message.ToRecipients[0].Name == "RFI")
{
Logger.LoggerAsync.InstanceOf.GeneralLogger.Warn("Going to archive answered RFIs for {0}", message.Categories[0]);
var results = this.GetMessagesOfSameCategory(message);
success = this.MoveEmailsToFolder(results, store);
}
}
return(success);
}
private bool setCategory(Enum.QuestionTypes result, EmailMessage message, string category, Entity.Store store)
{
bool isSuccess = false;
// check to see if the subject line had all of the information needed, otherwise look through the email body
if (result == Enum.QuestionTypes.Success)
{
message.Categories.Clear();
message.Categories.Add(category);
isSuccess = true;
}
else if (result == Enum.QuestionTypes.RequestForInformation)
{
result = Utilities.Categorizer.InstanceOf.TryCategorizationFromText(message.Body, store, out category);
// if after searching the body we figured out the RFI # then great, add it to the category
switch (result)
{
case Enum.QuestionTypes.None:
break;
case Enum.QuestionTypes.Success:
// break;
case Enum.QuestionTypes.RequestForInformation:
message.Categories.Clear();
message.Categories.Add(category);
isSuccess = true;
break;
case Enum.QuestionTypes.BidQuestion:
break;
case Enum.QuestionTypes.VendorQuestion:
break;
case Enum.QuestionTypes.ProtoQuestion:
break;
case Enum.QuestionTypes.GenericQuestion:
break;
default:
throw new Exception("Invalid value for QuestionTypes");
}
}
return(isSuccess);
}
public bool AssignCategory(EmailMessage message, out Entity.Store store)
{
string category;
bool isSuccess = false;
var emailSubject = message.Subject;
try {
var result = Utilities.Categorizer.InstanceOf.TryCategorizationFromString(emailSubject, out category, out store);
isSuccess = this.setCategory(result, message, category, store);
try {
// TODO: make this test smarter, we only want to check and download attachments on the very first email
if (message.Sender.Name == "Amy Mills" && message.ToRecipients[0].Name == "RFI")
{
var success = this.TryGetAndAttachDocuments(message, store, category);
if (success)
{
// disable saving attachments as it currently does not find the server paths correctly
/*var fileHandler = new Utilities.FileHandler(store);
*
* fileHandler.SaveAttachmentsToFolder(message.Attachments);*/
}
}
} catch {
// for now we'll forget about the attachments.
}
//this.AddToRfiIndex(message.Body.Text);
} catch (Exception exception) {
// test if the message is an RFI
if (IsRfi(message))
{
// the message is an RFI
// test if it is a walmart job
var isWalmart = this.IsWalmartJob(message);
if (isWalmart)
{
System.Collections.Generic.List <Entity.Store> storeList;
// is a walmart job. we need to figure out which store it is
var result = Utilities.Categorizer.InstanceOf.DiscoverProject(message, out category, out storeList);
store = storeList[0]; //TODO: iterate the store list
isSuccess = this.setCategory(result, message, category, store);
}
else
{
// not a walmart job.
// FIXME: figure out what kind of job it is and give the store object the correct type.
// For now we'll just move the email to the general rfi box.
store = new Entity.Store(); // return an empty store object becuase we have to.
store.Type = Enum.ProjectTypes.General;
}
}
else
{
// message is not an RFI. so we'll ignore it.
store = new Entity.Store();
store.Type = Enum.ProjectTypes.None;
isSuccess = false;
}
}
return(isSuccess);
}
public FileHandler(Entity.Store store)
{
this.GetFileServerProjectPath(store);
this.store = store;
}
/// <summary>
/// Attempts to provide a category based upon some input string.
/// This method looks for store and sequennce numbers.
/// </summary>
/// <param name="guess">the string to attempt to parse</param>
/// <param name="category">Contains the category string if function returns true.
/// <para>If function returns false this value will be String.Empty</para>
/// </param>
/// <returns>boolean true or false</returns>
public Enum.QuestionTypes TryCategorizationFromString(string guess, out string category, out Entity.Store store)
{
var guessStore = this.parser.GetStoreNumberAndSequenceFromHaystack(guess);
System.Collections.Generic.List <Entity.Store> storeList;
if (guessStore["sequence"].HasValue)
{
storeList = this.connector.GetStore(guessStore["number"].Value, guessStore["sequence"].Value);
}
else
{
storeList = this.connector.GetStore(guessStore["number"].Value);
}
store = storeList[0];
if (typeof(Entity.Store) != store.GetType())
{
throw new ArgumentNullException("No store found");
}
if (storeList.Count > 1)
{
category = string.Empty;
return(Enum.QuestionTypes.None);
}
var rfiNumber = this.parser.GetRfiNumberWithPadding(guess);
var builder = new System.Text.StringBuilder();
builder.AppendFormat("{0} {1}-{2} ",
store.City,
store.Number.ToString(),
store.Sequence.ToString());
if (rfiNumber != string.Empty)
{
builder.AppendFormat("RFI: {0}", rfiNumber);
}
else if (this.parser.IsBidQuestion(guess))
{
builder.Append("Bid Question");
}
else if (this.parser.IsRfiQuestion(guess))
{
builder.AppendFormat("RFI");
category = builder.ToString();
return(Enum.QuestionTypes.RequestForInformation);
}
else
{
category = string.Empty;
return(Enum.QuestionTypes.None);
}
category = builder.ToString();
return(Enum.QuestionTypes.Success);
}
public bool Write(DirectoryInfo directory, List <KeyValuePair <FileInfo, byte[]> > files, Entity.Store store)
{
var projects = from elements in this.XmlDocument.Elements("project")
where (int)elements.Attribute("number") == store.ProjectNumber
select elements;
var count = projects.Count();
XElement project;
if (count < 1)
{
project = new XElement(
"project",
new XAttribute("number", store.ProjectNumber),
new XAttribute("name", store.City)
);
this.XmlDocument.Add(project);
}
else if (count == 1)
{
project = projects.First();
}
else
{
throw new ArgumentOutOfRangeException("XmlData:projects", "Project entry must be unique");
}
var directories = from elements in projects.Elements()
where (string)elements.Attribute("name") == directory.Name
select elements;
count = directories.Count();
XElement folder;
if (count < 1)
{
folder = new XElement(
"folder",
new XAttribute("name", directory.Name),
new XAttribute("count", 0),
new XAttribute("date-modified", directory.LastWriteTime.ToString("u"))
);
project.Add(folder);
}
else if (count == 1)
{
folder = directories.First();
}
else
{
throw new ArgumentOutOfRangeException("XmlData:directories", "Directories must be unique for each prject");
}
var items = folder.Elements();
foreach (var pair in files)
{
var item = items.Where(x => (string)x.Attribute("name") == pair.Key.Name);
if (item.Count() == 0)
{
folder.Add(
new XElement(
"item",
new XAttribute("name", pair.Key.Name),
new XAttribute("size", pair.Key.Length),
new XAttribute("date-modified", pair.Key.LastWriteTime.ToString("u")),
new XElement(
"hash",
this.ByteConverter(pair.Value),
new XAttribute("method", "sha512")
)
)
);
var filesInFolder = int.Parse(folder.Attribute("count").Value);
filesInFolder++;
folder.Attribute("count").Value = filesInFolder.ToString();
}
}
this.XmlDocument.Save(FullPathName);
return(true);
}
