addSenderToMessage() private method

private addSenderToMessage ( domain sender, Message message ) : void
sender domain
message gov.va.medora.mdo.domain.sm.Message
return void
Example #1
0
        public Message saveDraft(Message message)
        {
            if (message == null || String.IsNullOrEmpty(message.Body) || message.MessageThread == null || message.CompletedDate.Year > 1900)
            {
                throw new MdoException("Invalid message");
            }
            if (message.SenderId <= 0)
            {
                throw new MdoException("Invalid user ID");
            }
            //if (message.MessageThread != null && message.MessageThread.Id > 0)
            //{
            //    throw new MdoException("Can't save more than on draft message to a thread");
            //}
            domain.sm.User sender = new UserDao(_cxn).getUserById(Convert.ToInt32(message.SenderId));
            if (sender == null)
            {
                throw new MdoException("No user found with that ID");
            }

            // is draft new or should we update
            if (message.Id > 0)
            {
                // get message - see if it's ripe for updating
                Message dbMessage = getMessageComplete(message.Id);
                if (dbMessage == null || dbMessage.Id <= 0 || dbMessage.MessageThread == null || dbMessage.MessageThread.Id <= 0 || dbMessage.Addressees == null ||
                    dbMessage.Addressees.Count != 1)
                {
                    throw new MdoException("Invalid message ID");
                }
                if (dbMessage.SenderId != message.SenderId || dbMessage.Addressees[0].Owner.Id != message.SenderId)
                {
                    throw new MdoException("Can't edit another user's messages");
                }
                if (dbMessage.SentDate.Year > 1900 || dbMessage.CompletedDate.Year > 1900)
                {
                    throw new MdoException("This message has already been sent - not a valid draft");
                }
                if (dbMessage.Addressees.Count > 1)
                {
                    throw new MdoException("Data integrity - this message has already been addressed to more than one user");
                }
                // need to copy over important fields before we assign dbMessage to message
                dbMessage.Body = message.Body;
                dbMessage.Checksum = gov.va.medora.utils.StringUtils.getMD5Hash(message.Body);
                dbMessage.Oplock = message.Oplock; // need to copy this over because it came from the client
                // if mail group changed
                if (message.MessageThread != null && message.MessageThread.MailGroup != null && message.MessageThread.MailGroup.Id > 0 && message.MessageThread.MailGroup.Id != dbMessage.MessageThread.MailGroup.Id)
                {
                    dbMessage.MessageThread.MailGroup = message.MessageThread.MailGroup;
                }
                // TODO - figure out copying over of message thread properties
                dbMessage.MessageThread.MessageCategoryType = message.MessageThread.MessageCategoryType;
                dbMessage.MessageThread.Subject = message.MessageThread.Subject;
                dbMessage.MessageThread.Oplock = message.MessageThread.Oplock;

                if (message.RecipientId > 0 && dbMessage.RecipientId != message.RecipientId)
                {
                    checkValidMessageRecipient(message, sender);
                    dbMessage.RecipientId = message.RecipientId;
                    dbMessage.RecipientName = message.RecipientName;
                    dbMessage.RecipientType = message.RecipientType;
                }
                message = dbMessage;

                try
                {
                    _cxn.beginTransaction();
                    updateThread(dbMessage.MessageThread);
                    message = updateMessage(dbMessage);
                    message.MessageThread = dbMessage.MessageThread;
                    _cxn.commitTransaction();
                }
                catch (Exception)
                {
                    _cxn.rollbackTransaction();
                    throw;
                }

            }
            else
            {
                if (message.MessageThread == null)
                {
                    throw new MdoException("No thread defined for new draft message");
                }

                message.SenderId = sender.Id;
                message.SenderName = sender.getName();
                message.SenderType = sender.ParticipantType;

                if (sender.ParticipantType == domain.sm.enums.ParticipantTypeEnum.PATIENT)
                {
                    checkValidMessageRecipientPatient(message);
                }
                else if (sender.ParticipantType == domain.sm.enums.ParticipantTypeEnum.CLINICIAN)
                {
                    checkValidMessageRecipientProvider(message);
                }
                try
                {
                    _cxn.beginTransaction();
                    domain.sm.Thread t = null;
                    if (message.MessageThread.Id <= 0)
                    {
                        t = createThread(message.MessageThread);
                    }
                    else
                    {
                        t = getThread(message.MessageThread.Id);
                        if (t == null || t.Id <= 0)
                        {
                            throw new MdoException("No thread found for that thread ID");
                        }
                    }
                    message = createMessage(message);
                    message.MessageThread = t;
                    AddresseeDao addrDao = new AddresseeDao(_cxn);
                    addrDao.addSenderToMessage(sender, message);
                    addrDao.createAddressees(message.Addressees, message.Id);
                    _cxn.commitTransaction();
                }
                catch (Exception)
                {
                    _cxn.rollbackTransaction();
                    throw;
                }
            }

            return message;
        }
Example #2
0
        internal Message preparePatientReply(Message original, Message reply, domain.sm.User sender)
        {
            if (original.MessageThread == null || original.MessageThread.MailGroup == null || original.MessageThread.MailGroup.Id <= 0)
            {
                throw new MdoException("No message thread or triage group defined");
            }
            reply.SenderType = sender.ParticipantType;
            reply.SenderName = sender.getName();
            reply.RecipientId = original.MessageThread.MailGroup.Id;
            checkValidMessageRecipientPatient(reply); // One would *think* the above line would validate this but, just in case there was some previous data integrity issue, we should check anyways. The helper function also sets other parameters (group name, etc) so not a wasted call

            AddresseeDao addrDao = new AddresseeDao(_cxn);
            addrDao.addSenderToMessage(sender, reply);
            addrDao.addRecipientsToMessage(Convert.ToInt32(reply.RecipientId), reply);

            return reply;
        }