public void testUpdateLastNotificationSqlStatement()
{
UserDao dao = new UserDao(_cxn);
OracleQuery query = dao.buildUpdateLastEmailNotificationQuery(
new domain.sm.User()
{
Email = "[email protected]",
EmailNotification = domain.sm.enums.EmailNotificationEnum.EACH_MESSAGE,
Id = 1,
LastNotification = DateTime.Now
});
Assert.IsTrue(String.Equals(query.Command.CommandText, "UPDATE SMS.SMS_USER SET LAST_EMAIL_NOTIFICATION=:lastEmailNotification, OPLOCK=:oplockPlusOne WHERE USER_ID=:userId and OPLOCK=:oplock"));
}
public SmUserTO getUser(string pwd, string userId, string idType)
{
SmUserTO result = new SmUserTO();
if (String.IsNullOrEmpty(pwd))
{
result.fault = new dto.FaultTO("Must supply password");
}
else if (String.IsNullOrEmpty(userId))
{
result.fault = new dto.FaultTO("Must supply user ID");
}
else if (String.IsNullOrEmpty(idType) && !StringUtils.isNumeric(userId))
{
result.fault = new FaultTO("Invalid user ID");
}
else if (!String.IsNullOrEmpty(idType) && !String.Equals(idType, "SMID", StringComparison.CurrentCultureIgnoreCase) &&
!String.Equals(idType, "ICN", StringComparison.CurrentCultureIgnoreCase) && !String.Equals(idType, "SSN", StringComparison.CurrentCultureIgnoreCase))
{
result.fault = new FaultTO("Invalid id type", "Use one of the following: SMID, ICN, SSN");
}
if (result.fault != null)
{
return result;
}
try
{
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource() { ConnectionString = pwd }))
{
UserDao dao = new UserDao(cxn);
if (String.IsNullOrEmpty(idType) || String.Equals(idType, "SMID", StringComparison.CurrentCultureIgnoreCase))
{
result = new SmUserTO(dao.getUserDetail(Convert.ToInt32(userId)));
}
else if (String.Equals(idType, "ICN", StringComparison.CurrentCultureIgnoreCase))
{
result = new SmUserTO(dao.getUserDetail(dao.getUserByIcn(userId).Id));
}
else if (String.Equals(idType, "SSN", StringComparison.CurrentCultureIgnoreCase))
{
// TODO - write get user by SSN function
result.fault = new FaultTO("SSN lookup not currently enabled. Please try again later");
//result = new SmUserTO(dao.getUserDetail(dao.getUserBySsn(userId)));
}
else
{
throw new Exception("Invalid user type"); // should never get here with fault handling section but... just in case
}
}
}
catch (Exception exc)
{
result.fault = new dto.FaultTO(exc);
}
return result;
}
public void testGetUserByIdSqlStatement()
{
UserDao dao = new UserDao(_cxn);
OracleQuery query = dao.buildGetUserByIdQuery(1);
Assert.IsTrue(String.Equals(query.Command.CommandText, "SELECT USER_ID, FIRST_NAME, LAST_NAME, USER_TYPE, STATUS, EMAIL_ADDRESS, OPLOCK, ACTIVE, DOB, ICN, SSN, STATION_NO, DUZ, EMAIL_NOTIFICATION, DEFAULT_MESSAGE_FILTER, LAST_EMAIL_NOTIFICATION, NSSN, PROVIDER, EXTERNAL_USER_NAME FROM SMS.sms_user WHERE USER_ID = :userId"));
}
public void testGetValidRecipientsForPatientSqlStatement()
{
UserDao dao = new UserDao(_cxn);
OracleQuery query = dao.buildGetValidRecipientsForPatientQuery(1);
Assert.IsTrue(String.Equals(query.Command.CommandText, "SELECT TG.TRIAGE_GROUP_ID, TG.TRIAGE_GROUP_NAME, TG.DESCRIPTION FROM SMS.PATIENT_TRIAGE_MAP PTM JOIN SMS.TRIAGE_RELATION TR ON PTM.RELATION_ID=TR.RELATION_ID JOIN SMS.TRIAGE_GROUP TG ON TG.TRIAGE_GROUP_ID=TR.TRIAGE_GROUP_ID WHERE PTM.USER_ID = :userId AND PTM.ACTIVE=1"));
}
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;
}
public void testGetTriageGroupMemberIdsSqlStatement()
{
UserDao dao = new UserDao(_cxn);
OracleQuery query = dao.buildGetTriageGroupMembersQuery(1);
Assert.IsTrue(String.Equals(query.Command.CommandText, "SELECT CTM.USER_ID, USR.EMAIL_ADDRESS, USR.OPLOCK, USR.EMAIL_NOTIFICATION, USR.LAST_EMAIL_NOTIFICATION FROM SMS.CLINICIAN_TRIAGE_MAP CTM JOIN SMS.SMS_USER USR ON CTM.USER_ID=USR.USER_ID WHERE CTM.TRIAGE_GROUP_ID=:groupId AND CTM.ACTIVE=1"));
}
internal Message prepareReply(Message original, Message reply)
{
if (original == null || original.Id <= 0 || reply == null || reply.SenderId <= 0 || String.IsNullOrEmpty(reply.Body))
{
throw new ArgumentException("Insufficient information to process request");
}
original = getMessageComplete(original.Id);
if (original == null || original.Id <= 0 || original.MessageThread == null || original.MessageThread.Id <= 0)
{
throw new MdoException("No message for that original message ID");
}
reply.MessageThread = original.MessageThread;
domain.sm.User sender = new UserDao(_cxn).getUserById(Convert.ToInt32(reply.SenderId));
if (sender == null)
{
throw new MdoException("No user exists for that user ID");
}
if (sender.ParticipantType == domain.sm.enums.ParticipantTypeEnum.PATIENT)
{
reply = preparePatientReply(original, reply, sender);
}
else if (reply.SenderType == domain.sm.enums.ParticipantTypeEnum.CLINICIAN)
{
reply = prepareProviderReply(original, reply, sender);
}
else
{
throw new NotImplementedException("Currently not allowed to send as " + Enum.GetName(typeof(domain.sm.enums.ParticipantTypeEnum), reply.SenderType));
}
return reply;
}
/// <summary>
/// Prepare a message for sending. Creates thread if needed. Assigns addressees. Verifies message recipient
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
internal Message prepareMessage(Message message)
{
if (message.MessageThread == null)
{
throw new MdoException(MdoExceptionCode.ARGUMENT_NULL, "No thread defined");
}
if (message.MessageThread.Id <= 0 && String.IsNullOrEmpty(message.MessageThread.Subject))
{
throw new MdoException(MdoExceptionCode.ARGUMENT_NULL, "No message ID or message subject specified");
}
if (message.SenderId <= 0)
{
throw new MdoException(MdoExceptionCode.ARGUMENT_NULL_PATIENT_ID, "No user associated with message");
}
if (message.MessageThread.Id <= 0)
{
message.MessageThread = createThread(message.MessageThread); // the message.MessageThread should have the fields needed to create
}
domain.sm.User sender = new UserDao(_cxn).getUserById(Convert.ToInt32(message.SenderId));
new AddresseeDao(_cxn).addSenderToMessage(sender, message);
message.SenderName = sender.getName();
message.SenderType = sender.ParticipantType;
if (message.SentDate.Year > 1900) // if message is ready to be sent
{
if (sender.UserType == domain.sm.enums.UserTypeEnum.PATIENT) // if user is a patient, make sure recipient is ok
{
return prepareCompletedPatientMessage(message);
}
else if (sender.UserType == domain.sm.enums.UserTypeEnum.CLINICIAN)
{
return prepareCompletedProviderMessage(message);
}
else if (sender.UserType == domain.sm.enums.UserTypeEnum.ADMINISTRATOR)
{
// TBD - do these users have any restrictions???
}
}
else if (message.SentDate.Year < 1900)
{
if (sender.UserType == domain.sm.enums.UserTypeEnum.PATIENT)
{
return prepareIncompletePatientMessage(message);
}
else if (sender.UserType == domain.sm.enums.UserTypeEnum.CLINICIAN)
{
// TODO - implement some code to take care of incomplete messages
}
else if (sender.UserType == domain.sm.enums.UserTypeEnum.ADMINISTRATOR)
{
// TODO - implement some code to take care of incomplete messages
}
}
return message;
}
internal Message prepareCompletedProviderMessage(domain.sm.Message message)
{
// TODO - need to implement provider stuff...
return message;
if (message.RecipientType == domain.sm.enums.ParticipantTypeEnum.PATIENT || message.RecipientType == domain.sm.enums.ParticipantTypeEnum.CLINICIAN)
{
domain.sm.User recipient = new UserDao(_cxn).getUserById(Convert.ToInt32(message.RecipientId));
if (recipient == null)
{
throw new MdoException("No user for that recipient ID");
}
message.RecipientName = recipient.getName();
message.RecipientType = recipient.ParticipantType;
}
else if (message.RecipientType == domain.sm.enums.ParticipantTypeEnum.DISTRIBUTION_GROUP)
{
// TODO implement some code to set the correct recipient values
}
else if (message.RecipientType == domain.sm.enums.ParticipantTypeEnum.CLINCIAN_TRIAGE)
{
// TODO implement some code to set the correct recipient values
}
}
internal void checkValidMessageRecipientPatient(domain.sm.Message message)
{
IList<TriageGroup> validGroups = new UserDao(_cxn).getValidRecipientsForPatient(Convert.ToInt32(message.SenderId)); // should be the user ID - senderId and recipient don't change
if (validGroups == null || validGroups.Count == 0)
{
throw new MdoException("The user is not assigned any recipient groups");
}
TriageGroup validGroup = null;
foreach (TriageGroup group in validGroups)
{
if (group.Id == Convert.ToInt32(message.RecipientId))
{
validGroup = group;
break;
}
}
// if we didn't find a valid group using the recipient ID, we can see if the message thread's mail group property contains that data
if (validGroup == null)
{
if (message.MessageThread != null && message.MessageThread.MailGroup != null && message.MessageThread.MailGroup.Id > 0)
{
foreach (TriageGroup group in validGroups)
{
if (group.Id == message.MessageThread.MailGroup.Id)
{
message.RecipientId = message.MessageThread.MailGroup.Id; // correct recipient to use the mail group ID
validGroup = message.MessageThread.MailGroup;
break;
}
}
}
}
// if we still don't have a valid group then throw an error
if (validGroup == null)
{
throw new MdoException("The patient does not have permission to send secure messages to that group");
}
message.MessageThread.MailGroup = new TriageGroup() { Id = validGroup.Id, Name = validGroup.Name, Oplock = validGroup.Oplock };
message.RecipientName = validGroup.Name;
message.RecipientType = domain.sm.enums.ParticipantTypeEnum.CLINCIAN_TRIAGE;
}
internal void checkValidMessageRecipient(domain.sm.Message message)
{
if (message == null || message.SenderId <= 0)
{
throw new MdoException("No sender for message");
}
domain.sm.User sender = new UserDao(_cxn).getUserById(Convert.ToInt32(message.SenderId));
checkValidMessageRecipient(message, sender);
}
