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); }