/// <summary>
/// Update Assessment
/// </summary>
/// <param name="assessment"></param>
/// <returns></returns>
public Response <ClinicalAssessmentModel> UpdateAssessment(ClinicalAssessmentModel assessment)
{
var spParameters = BuildSpParams(assessment);
var repository = _unitOfWork.GetRepository <ClinicalAssessmentModel>(SchemaName.Clinical);
return(_unitOfWork.EnsureInTransaction <Response <ClinicalAssessmentModel> >(repository.ExecuteNQStoredProc, "usp_UpdateClinicalAssessments", spParameters, forceRollback: assessment.ForceRollback.GetValueOrDefault(false)));
}
public IHttpActionResult UpdateAssessment(ClinicalAssessmentModel assessment)
{
if (ModelState.IsValid)
{
return(new HttpResult <Response <ClinicalAssessmentModel> >(_assessmentRuleEngine.UpdateAssessment(assessment), Request));
}
else
{
var errorMessage = ModelState.ParseError();
var validationResponse = new Response <ClinicalAssessmentModel>()
{
DataItems = new List <ClinicalAssessmentModel>(), ResultCode = -1, ResultMessage = errorMessage
};
return(new HttpResult <Response <ClinicalAssessmentModel> >(validationResponse, Request));
}
}
public void AddAssessment_Failed()
{
// Arrange
var url = baseRoute + "addAssessment";
var assessment = new ClinicalAssessmentModel
{
AssessmentID = 4,
ContactID = -1,
TakenTime = DateTime.UtcNow,
TakenBy = 1,
ResponseID = 1
};
// Act
var response = communicationManager.Post <ClinicalAssessmentModel, Response <ClinicalAssessmentModel> >(assessment, url);
// Assert
Assert.IsTrue(response != null, "Response can't be null");
Assert.IsTrue(response.ResultCode != 0, "clinical assessment has been created for invalid contact.");
}
public void AddAssessment_Success()
{
// Arrange
var url = baseRoute + "addAssessment";
var assessment = new ClinicalAssessmentModel
{
AssessmentID = 4,
ContactID = 1,
TakenTime = DateTime.UtcNow,
TakenBy = 1,
ResponseID = 1
};
// Act
var response = communicationManager.Post <ClinicalAssessmentModel, Response <ClinicalAssessmentModel> >(assessment, url);
// Assert
// Assert
Assert.IsTrue(response != null, "Response can't be null");
Assert.IsTrue(response.ResultCode == 0, "Clinical assessment could not be created.");
}
/// <summary>
/// Build stored procedure parameters
/// </summary>
/// <param name="assessment"></param>
/// <returns></returns>
private List <SqlParameter> BuildSpParams(ClinicalAssessmentModel assessment)
{
var spParameters = new List <SqlParameter>();
if (assessment.ClinicalAssessmentID > 0) // Only in case of Update
{
spParameters.Add(new SqlParameter("ClinicalAssessmentID", assessment.ClinicalAssessmentID));
}
spParameters.AddRange(new List <SqlParameter> {
new SqlParameter("ContactID", assessment.ContactID),
new SqlParameter("AssessmentDate", (object)assessment.TakenTime ?? string.Empty),
new SqlParameter("UserID", assessment.TakenBy),
new SqlParameter("AssessmentID", assessment.AssessmentID),
new SqlParameter("ResponseID", (object)assessment.ResponseID ?? DBNull.Value),
new SqlParameter("AssessmentStatusID", (object)assessment.EncounterID ?? DBNull.Value),
new SqlParameter("ModifiedOn", assessment.ModifiedOn ?? DateTime.Now)
});
return(spParameters);
}
/// <summary>
/// To the model.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
public static ClinicalAssessmentModel ToModel(this ClinicalAssessmentViewModel model)
{
if (model == null)
{
return(null);
}
var entity = new ClinicalAssessmentModel
{
ClinicalAssessmentID = model.ClinicalAssessmentID,
AssessmentID = model.AssessmentID,
ResponseID = model.ResponseID,
SectionID = model.SectionID,
ContactID = model.ContactID,
EncounterID = model.EncounterID,
TakenBy = model.TakenBy,
TakenTime = model.TakenTime,
ModifiedOn = model.ModifiedOn
};
return(entity);
}
/// <summary>
/// To the ViewModel
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public static ClinicalAssessmentViewModel ToViewModel(this ClinicalAssessmentModel entity)
{
if (entity == null)
{
return(null);
}
var model = new ClinicalAssessmentViewModel
{
ClinicalAssessmentID = entity.ClinicalAssessmentID,
AssessmentID = entity.AssessmentID,
ResponseID = entity.ResponseID,
SectionID = entity.SectionID,
ContactID = entity.ContactID,
EncounterID = entity.EncounterID,
TakenBy = entity.TakenBy,
TakenTime = entity.TakenTime,
ModifiedOn = entity.ModifiedOn
};
return(model);
}
public void UpdateAssessment_Failed()
{
// Arrange
var url = baseRoute + "updateAssessment";
//Arrange
var assessment = new ClinicalAssessmentModel
{
ClinicalAssessmentID = -1,
AssessmentID = 4,
ContactID = -1,
TakenTime = DateTime.UtcNow,
TakenBy = 1,
ResponseID = 1
};
// Act
var response = communicationManager.Put <ClinicalAssessmentModel, Response <ClinicalAssessmentModel> >(assessment, url);
// Assert
Assert.IsTrue(response != null, "Response can't be null");
Assert.IsTrue(response.ResultCode != 0, "Update clinical assessment could be Updated.");
}
/// <summary>
/// To update assessment
/// </summary>
/// <param name="assessment"></param>
/// <returns></returns>
public Response <ClinicalAssessmentModel> UpdateAssessment(ClinicalAssessmentModel assessment)
{
const string apiUrl = BaseRoute + "UpdateAssessment";
return(_communicationManager.Put <ClinicalAssessmentModel, Response <ClinicalAssessmentModel> >(assessment, apiUrl));
}
public string Post()
{
DanpheHTTPResponse <object> responseData = new DanpheHTTPResponse <object>();
//DanpheTeleMedDbContext dbContext = new DanpheTeleMedDbContext(connString);
responseData.Status = "OK";
try
{
string str = new StreamReader(Request.Body).ReadToEnd();
string reqType = Request.Query["reqType"];
responseData.Results = str + reqType;
#region Save User
if (reqType == "save-user")
{
UserModel user = DanpheJSONConvert.DeserializeObject <UserModel>(str);
if (user != null)
{
var usr = dbContext.User.Where(u => u.UserName == user.UserName).Select(a => a).ToList();
if (usr.Count > 0)
{
responseData.Status = "Falied";
responseData.ErrorMessage = "User already exits";
}
else
{
dbContext.User.Add(user);
dbContext.SaveChanges();
responseData.Results = user;
responseData.Status = "OK";
}
}
else
{
responseData.Status = "Failed";
responseData.ErrorMessage = "user information not received";
}
}
#endregion
#region Save Conference
else if (reqType == "save-new-conference")
{
ConferenceModel conference = DanpheJSONConvert.DeserializeObject <ConferenceModel>(str);
if (conference != null)
{
ConferenceUserModel conferenceUser = new ConferenceUserModel();
conferenceUser.ConferenceRoomId = conference.ConferenceRoomId;
conferenceUser.UserName = GetUserName(dbContext, conference.CreatedBy);
conferenceUser.JoinTime = conference.CreatedOn;
dbContext.Conference.Add(conference);
dbContext.ConferenceUser.Add(conferenceUser);
dbContext.SaveChanges();
responseData.Results = conference;
responseData.Status = "OK";
}
}
#endregion
#region Add new user in conference
else if (reqType == "add-conference-user")
{
ConferenceUserModel conferenceUser = DanpheJSONConvert.DeserializeObject <ConferenceUserModel>(str);
if (conferenceUser != null)
{
dbContext.ConferenceUser.Add(conferenceUser);
dbContext.SaveChanges();
responseData.Results = conferenceUser;
responseData.Status = "OK";
}
}
#endregion
#region Save conference chat
else if (reqType == "save-conference-chat")
{
ConferenceChatModel conferenceChat = DanpheJSONConvert.DeserializeObject <ConferenceChatModel>(str);
if (conferenceChat != null)
{
dbContext.ConferenceChat.Add(conferenceChat);
dbContext.SaveChanges();
responseData.Results = conferenceChat;
responseData.Status = "OK";
}
}
#endregion
#region Save new session of p2p connection
else if (reqType == "save-new-session")
{
SessionTxnModel sessionTxn = DanpheJSONConvert.DeserializeObject <SessionTxnModel>(str);
if (sessionTxn != null)
{
dbContext.SessionTxns.Add(sessionTxn);
dbContext.SaveChanges();
SessionUserTxnModel sessionUserTxn = new SessionUserTxnModel();
sessionUserTxn.SessionId = sessionTxn.SessionId;
sessionUserTxn.SessionOwnerId = sessionTxn.CreatedBy;
sessionUserTxn.OwnerJoinTime = sessionTxn.CreatedOn;
sessionUserTxn.UserId = sessionTxn.CallingTo;
sessionUserTxn.UserJoinTime = sessionTxn.CreatedOn;
dbContext.SessionUserTxns.Add(sessionUserTxn);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region Add new user in p2p session
else if (reqType == "add-session-user")
{
SessionUserTxnModel sessionUserTxn = DanpheJSONConvert.DeserializeObject <SessionUserTxnModel>(str);
if (sessionUserTxn != null)
{
if (sessionUserTxn.SessionOwnerId > 0)
{
dbContext.SessionUserTxns.Add(sessionUserTxn);
dbContext.SaveChanges();
}
else
{
var newuser = (from u in dbContext.SessionUserTxns
where u.SessionId == sessionUserTxn.SessionId
select u).FirstOrDefault();
newuser.UserId = sessionUserTxn.UserId;
newuser.UserJoinTime = sessionUserTxn.UserJoinTime;
dbContext.SessionUserTxns.Attach(newuser);
dbContext.Entry(newuser).Property(a => a.UserId).IsModified = true;
dbContext.Entry(newuser).Property(a => a.UserJoinTime).IsModified = true;
dbContext.Entry(newuser).State = EntityState.Modified;
dbContext.SaveChanges();
}
}
responseData.Results = sessionUserTxn;
responseData.Status = "OK";
}
#endregion
#region Save session chat in p2p connection
else if (reqType == "save-session-chat")
{
SessionChatModel sessionChat = DanpheJSONConvert.DeserializeObject <SessionChatModel>(str);
if (sessionChat != null)
{
var schat = (from s in dbContext.SessionUserTxns
where s.SessionId == sessionChat.SessionId
select new
{
s.SessionOwnerId,
s.UserId
}).FirstOrDefault();
sessionChat.ReceiverId = (schat.UserId == sessionChat.SenderId) ? schat.SessionOwnerId : schat.UserId;
dbContext.SessionChat.Add(sessionChat);
dbContext.SaveChanges();
responseData.Results = sessionChat;
responseData.Status = "OK";
}
}
#endregion
#region save assessment
else if (reqType == "save-assessment")
{
ClinicalAssessmentModel assessment = DanpheJSONConvert.DeserializeObject <ClinicalAssessmentModel>(str);
if (assessment != null)
{
dbContext.Assessment.Add(assessment);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save complain
else if (reqType == "save-complain")
{
ClinicalComplainModel complain = DanpheJSONConvert.DeserializeObject <ClinicalComplainModel>(str);
if (complain != null)
{
dbContext.Complain.Add(complain);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save examination
else if (reqType == "save-examination")
{
ClinicalExaminationModel examination = DanpheJSONConvert.DeserializeObject <ClinicalExaminationModel>(str);
if (examination != null)
{
dbContext.Examination.Add(examination);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save orders
else if (reqType == "save-orders")
{
ClinicalOrderModel order = DanpheJSONConvert.DeserializeObject <ClinicalOrderModel>(str);
if (order != null)
{
dbContext.Order.Add(order);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save plan
else if (reqType == "save-plan")
{
ClinicalPlanModel plan = DanpheJSONConvert.DeserializeObject <ClinicalPlanModel>(str);
if (plan != null)
{
dbContext.Plan.Add(plan);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region save consult request
else if (reqType == "save-consult-request")
{
ConsultRequestModel consult = DanpheJSONConvert.DeserializeObject <ConsultRequestModel>(str);
if (consult != null)
{
dbContext.ConsultRequest.Add(consult);
dbContext.SaveChanges();
responseData.Status = "OK";
}
}
#endregion
#region End Video Call
else if (reqType == "end-video-call")
{
SessionTxnModel sessionTxn = DanpheJSONConvert.DeserializeObject <SessionTxnModel>(str);
var es = (from st in dbContext.SessionTxns
where st.SessionId == sessionTxn.SessionId
select st).FirstOrDefault();
if (es != null)
{
es.EndTime = sessionTxn.EndTime;
dbContext.SessionTxns.Attach(es);
dbContext.Entry(es).Property(a => a.EndTime).IsModified = true;
dbContext.Entry(es).State = EntityState.Modified;
dbContext.SaveChanges();
}
responseData.Results = es;
responseData.Status = "OK";
}
#endregion
else
{
responseData.Results = "Wrong data";
responseData.Status = "OK";
}
}
catch (Exception ex)
{
responseData.Status = "Failed";
responseData.ErrorMessage = ex.Message + "exception details:" + ex.ToString();
}
return(DanpheJSONConvert.SerializeObject(responseData, true));
}
public IHttpActionResult UpdateAssessment(ClinicalAssessmentModel assessmentModel)
{
return(new HttpResult <Response <ClinicalAssessmentModel> >(_assessmentDataProvider.UpdateAssessment(assessmentModel), Request));
}
/// <summary>
/// To update assessment
/// </summary>
/// <param name="assessment"></param>
/// <returns></returns>
public Response <ClinicalAssessmentModel> UpdateAssessment(ClinicalAssessmentModel assessment)
{
return(_assessmentService.UpdateAssessment(assessment));
}
