/// <summary author="Austin Delaney" created="2019/04/25"> /// Replies to a thread by passing the message manager a new message with that thread's ID. /// </summary> /// <param name="thread">The thread to add the message to.</param> /// <param name="reply">The message to add to the thread.</param> /// <returns>Whether the operation was a success or not.</returns> public bool ReplyToThread(IMessageThread thread, Message reply) { if (null == thread) { throw new ArgumentNullException("Thread to add participants to cannot be null."); } if (null == reply) { throw new ArgumentNullException("Message to use as reply cannot be null."); } bool result = false; IMessageManager messageManager = new RealMessageManager(daoType); try { result = messageManager.CreateNewReply(thread, reply); } catch (Exception ex) { ExceptionLogManager.getInstance().LogException(ex); throw ex; } return(result); }
/// <summary author="Austin Delaney" created="2019/04/20"> /// Creates a new thread with a supplied message and then a supplied set of recipients, who will become the thread participants. /// Note that if a recipient is included by role/dept as well as by their specific username, the message will ignore their role/dept. /// </summary> /// <param name="message">The message used to initialize the thread.</param> /// <param name="recipients">The set of recipients to be included in the new thread.</param> /// <returns>The user specific thread view of the thread.</returns> public UserThread CreateNewThread(Message message, List <IMessagable> recipients) { if (null == message) { throw new ArgumentNullException("Message cannot be null"); } if (null == recipients) { recipients = new List <IMessagable>(); } if (!message.IsValid()) { throw new ArgumentException("Message is invalid, thread cannot be created."); } recipients.Add(message.Sender); int newThreadID; try { RealMessageManager messageManager = new RealMessageManager(daoType); newThreadID = messageManager.CreateNewMessage(message); } catch (Exception ex) { Exception exception = new Exception("Error while creating a new thread using supplied message", ex); ExceptionLogManager.getInstance().LogException(exception); throw exception; } UserThread newThread = new UserThread { ThreadID = newThreadID }; try { AddThreadParticipants(newThread, recipients); } catch (Exception ex) { Exception exception = new Exception("Error while adding recipients to new thread", ex); ExceptionLogManager.getInstance().LogException(exception); } return(GetUserThread(newThread, message.Sender)); }
/// <summary author="Austin Delaney" created="2019/04/25"> /// Gets a list of all user threads that a user is a participant in. /// </summary> /// <param name="user">The user/participant to find threads for.</param> /// <param name="showArchived">Include archived threads in the retrieval from the data store.</param> /// <returns>A list of compact thread objects</returns> public List <UserThreadView> GetUserThreadViewList(ISender user, bool showArchived) { if (null == user) { throw new ArgumentNullException("A user must be provided that is viewing the threads, cannot be null."); } List <UserThreadView> result = null; try { result = dao.GetUserThreadViews(user.Email, showArchived); } catch (Exception ex) { Exception exc = new Exception("Error while retrieving UserThreadView list for user: "******"Error while retrieving newest message for user: "******" in thread " + result[i].ThreadID, ex); ExceptionLogManager.getInstance().LogException(exc); } } return(result); }
/// <summary author="Austin Delaney" created="2019/04/25"> /// Gets a fully populated user specific view of a particular thread from the data store /// by searching for its ID. /// </summary> /// <param name="threadID">The ID of the thread to get data on.</param> /// <param name="user">The user who is viewing the thread.</param> /// <returns>The fully populated thread object representing the requested thread.</returns> public UserThread GetUserThread(int threadID, ISender user) { if (null == user) { throw new ArgumentNullException("A user must be provided that is viewing the thread, cannot be null."); } UserThread result; try { result = dao.GetUserThreadData(threadID, user.Email); } catch (Exception ex) { Exception exc = new Exception("Error occurred retrieving thread " + threadID + " data for user " + user.Email, ex); ExceptionLogManager.getInstance().LogException(exc); throw exc; } //Set the participants of the thread. Dictionary <IMessagable, string> participantsWithAlias = new Dictionary <IMessagable, string>(); //TRY and guess what this does try { //Get all the emails and aliases of the participants first Dictionary <string, string> emailsWithAlias = dao.GetThreadParticipantEmailAndAlias(threadID); //Setup the managers to get the properly formed data objects that those emails represent EmployeeManager employeeManager = new EmployeeManager(); GuestManager guestManager = new GuestManager(); MemberManagerMSSQL memberManager = new MemberManagerMSSQL(); //Heres the tricky part //Using the list of all your emails, get an IEnumerable of all the objects that are found to match those emails //Why is this so ugly? It's not. Your eyes simply can't appreciate it's beauty. IEnumerable <ISender> foundParticipants = new List <ISender>().Concat( employeeManager.SelectAllEmployees().Where(e => emailsWithAlias.Select(kp => kp.Key).Contains(e.Email))).Concat( guestManager.ReadAllGuests().Where(g => emailsWithAlias.Select(kp => kp.Key).Contains(g.Email))).Concat( memberManager.RetrieveAllMembers().Where(m => emailsWithAlias.Select(kp => kp.Key).Contains(m.Email))); //Using the list of objects you obtained, cast those objects to an imessagable and assign them the value that is found for their email foreach (var participantObject in foundParticipants) { participantsWithAlias[participantObject as IMessagable] = emailsWithAlias[participantObject.Email]; } } catch (Exception ex) { Exception exc = new Exception("Error while populating participants for thread " + threadID, ex); ExceptionLogManager.getInstance().LogException(exc); } result.ParticipantsWithAlias = participantsWithAlias; //Set the messages of the thread. IEnumerable <Message> messages = new List <Message>(); //Try to properly retrieve them from data store. If unsuccessful, log exception and set //thread messages to an empty list try { RealMessageManager manager = new RealMessageManager(daoType); messages = manager.RetrieveThreadMessages(new UserThread { ThreadID = threadID }); } catch (Exception ex) { Exception exc = new Exception("Unable to retrieve messages for thread " + threadID, ex); ExceptionLogManager.getInstance().LogException(exc); } result.Messages = messages.ToList(); //Return the (hopeuflly) fully formed UserThread object return(result); }