public static PatientTaskData GetInitialTaskRequest(GetInitializeTaskRequest request)
{
try
{
PatientTaskData result = null;
IRestClient client = new JsonServiceClient();
string url = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Patient/{4}/Goal/{5}/Task/Initialize",
DDPatientGoalsServiceUrl,
"NG",
request.Version,
request.ContractNumber,
request.PatientId,
request.PatientGoalId), request.UserId);
PutInitializeTaskResponse response = client.Put <PutInitializeTaskResponse>(url, new PutInitializeTaskRequest() as object);
if (response != null)
{
result = response.Task;
}
return(result);
}
catch (WebServiceException ex)
{
throw new WebServiceException("AD:GetInitialTaskRequest()::" + ex.Message, ex.InnerException);
}
}
public static PatientTask ConvertToTask(PatientTaskData t, List <CustomAttribute> taskAttributesLibrary)
{
PatientTask task = null;
if (t != null)
{
task = new PatientTask
{
Id = t.Id,
PatientGoalId = t.PatientGoalId,
TargetValue = t.TargetValue,
StatusId = t.StatusId,
TargetDate = t.TargetDate,
CustomAttributes = GetCustomAttributeDetails(t.CustomAttributes, taskAttributesLibrary),
BarrierIds = t.BarrierIds,
Description = t.Description,
StatusDate = t.StatusDate,
StartDate = t.StartDate,
ClosedDate = t.ClosedDate,
CreatedById = t.CreatedById,
GoalName = t.GoalName,
DeleteFlag = t.DeleteFlag,
TemplateId = t.TemplateId,
Details = t.Details
};
}
return(task);
}
internal static bool PostUpdateTaskRequest(PostPatientGoalRequest request, PatientTaskData td)
{
try
{
bool result = false;
List <string> taskIds = GetTaskIdsForRequest(request.Goal.Tasks);
IRestClient client = new JsonServiceClient();
string url = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Patient/{4}/Goal/{5}/Task/{6}/Update", DDPatientGoalsServiceUrl, "NG", request.Version, request.ContractNumber, request.PatientId, request.Goal.Id, td.Id), request.UserId);
PutUpdateTaskResponse response = client.Put <PutUpdateTaskResponse>(url, new PutUpdateTaskRequest {
Task = td, TaskIdsList = taskIds, UserId = request.UserId
} as object);
if (response != null)
{
result = true;
}
return(result);
}
catch (WebServiceException ex)
{
throw new WebServiceException("AD:PostUpdateTaskRequest()::" + ex.Message, ex.InnerException);
}
}
public static PatientTaskData ConvertToPatientTaskData(PatientTask t)
{
PatientTaskData data = null;
if (t != null)
{
data = new PatientTaskData
{
Id = t.Id,
CustomAttributes = GetAttributeData(t.CustomAttributes),
BarrierIds = t.BarrierIds,
Description = t.Description,
PatientGoalId = t.PatientGoalId,
StartDate = t.StartDate,
StatusId = t.StatusId,
StatusDate = t.StatusDate,
TargetDate = t.TargetDate,
TargetValue = t.TargetValue,
DeleteFlag = t.DeleteFlag,
TemplateId = t.TemplateId,
ClosedDate = t.ClosedDate,
Details = t.Details
};
}
return(data);
}
public static bool SavePatientGoalTasks(PostPatientGoalRequest request)
{
bool result = false;
try
{
if (request.Goal.Tasks != null && request.Goal.Tasks.Count > 0)
{
List <PatientTaskData> ptd = new List <PatientTaskData>();
request.Goal.Tasks.ForEach(t =>
{
PatientTaskData data = ConvertToPatientTaskData(t);
ptd.Add(data);
});
ptd.ForEach(td =>
{
GoalsEndpointUtil.PostUpdateTaskRequest(request, td);
});
}
else if (request.Goal.Tasks.Count == 0)
{
PatientTaskData pbd = new PatientTaskData {
Id = "0", PatientGoalId = request.PatientGoalId
};
result = GoalsEndpointUtil.PostUpdateTaskRequest(request, pbd);
}
return(result);
}
catch (Exception ex)
{
throw new Exception("AD:SavePatientGoalTasks()::" + ex.Message, ex.InnerException);
}
}
public GetPatientTaskByTemplateIdResponse GetPatientTaskByTemplateId(GetPatientTaskByTemplateIdRequest request)
{
GetPatientTaskByTemplateIdResponse result = null;
try
{
result = new GetPatientTaskByTemplateIdResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientTask);
PatientTaskData patientTaskData = repo.FindByTemplateId(request.GoalId, request.TemplateId) as PatientTaskData;
//if (patientGoalData != null)
//{
// //Get all barriers for a given goal
// patientGoalData.BarriersData = getBarriersByPatientGoalId(request, patientGoalData.Id);
// //Get all tasks for a given goal
// patientGoalData.TasksData = getTasksByPatientGoalId(request, patientGoalData.Id);
// //Get all interventions for a given goal
// patientGoalData.InterventionsData = getInterventionsByPatientGoalId(request, patientGoalData.Id);
//}
result.TaskData = patientTaskData;
result.Version = request.Version;
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public IEnumerable <object> Search(object request, List <string> patientGoalIds)
{
List <PatientTaskData> list = null;
GetPatientTasksDataRequest dataRequest = (GetPatientTasksDataRequest)request;
try
{
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
List <IMongoQuery> queries = new List <IMongoQuery>();
queries.Add(Query.EQ(MEPatientTask.DeleteFlagProperty, false));
if (dataRequest.StatusIds != null && dataRequest.StatusIds.Count > 0)
{
queries.Add(Query.In(MEPatientTask.StatusProperty, new BsonArray(dataRequest.StatusIds)));
}
if (patientGoalIds != null && patientGoalIds.Count > 0)
{
List <BsonValue> bsonList = Helper.ConvertToBsonValueList(patientGoalIds);
queries.Add(Query.In(MEPatientTask.PatientGoalIdProperty, bsonList));
}
IMongoQuery mQuery = Query.And(queries);
List <MEPatientTask> meTasks = null;
meTasks = ctx.PatientTasks.Collection.Find(mQuery).ToList();
if (meTasks != null && meTasks.Count > 0)
{
list = new List <PatientTaskData>();
foreach (MEPatientTask t in meTasks)
{
PatientTaskData taskData = new PatientTaskData
{
Id = t.Id.ToString(),
TargetValue = t.TargetValue,
PatientGoalId = t.PatientGoalId.ToString(),
StatusId = ((int)t.Status),
TargetDate = t.TargetDate,
BarrierIds = Helper.ConvertToStringList(t.BarrierIds),
Description = t.Description,
StatusDate = t.StatusDate,
StartDate = t.StartDate,
CustomAttributes = DTOUtil.GetCustomAttributeIdAndValues(t.Attributes),
ClosedDate = t.ClosedDate,
CreatedById = t.RecordCreatedBy.ToString(),
DeleteFlag = t.DeleteFlag,
Details = t.Details
};
var mePG = ctx.PatientGoals.Collection.Find(Query.EQ(MEPatientGoal.IdProperty, ObjectId.Parse(taskData.PatientGoalId))).SetFields(MEPatientGoal.NameProperty).FirstOrDefault();
if (mePG != null)
{
taskData.GoalName = mePG.Name;
}
list.Add(taskData);
}
}
}
return(list);
}
catch (Exception) { throw; }
}
public object FindByTemplateId(string patientGoalId, string entityID)
{
PatientTaskData taskData = null;
try
{
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
List <IMongoQuery> queries = new List <IMongoQuery>
{
Query.EQ(MEPatientTask.PatientGoalIdProperty, ObjectId.Parse(patientGoalId)),
Query.EQ(MEPatientTask.TemplateIdProperty, ObjectId.Parse(entityID)),
Query.In(MEPatientTask.StatusProperty, new BsonArray {
1, 3
}),
Query.EQ(MEPatientTask.DeleteFlagProperty, false),
Query.EQ(MEPatientTask.TTLDateProperty, BsonNull.Value)
};
var mQuery = Query.And(queries);
var b = ctx.PatientTasks.Collection.Find(mQuery).FirstOrDefault();
if (b != null)
{
taskData = new PatientTaskData
{
Id = b.Id.ToString(),
Description = b.Description,
PatientGoalId = b.PatientGoalId.ToString(),
BarrierIds = Helper.ConvertToStringList(b.BarrierIds),
StatusId = ((int)b.Status),
StatusDate = b.StatusDate,
StartDate = b.StartDate,
TargetValue = b.TargetValue,
CustomAttributes = DTOUtil.GetCustomAttributeIdAndValues(b.Attributes),
TargetDate = b.TargetDate,
ClosedDate = b.ClosedDate,
CreatedById = b.RecordCreatedBy.ToString(),
DeleteFlag = b.DeleteFlag,
Details = b.Details
};
var mePG = ctx.PatientGoals.Collection.Find(Query.EQ(MEPatientGoal.IdProperty, ObjectId.Parse(taskData.PatientGoalId))).SetFields(MEPatientGoal.PatientIdProperty, MEPatientGoal.NameProperty).FirstOrDefault();
if (mePG != null)
{
taskData.GoalName = mePG.Name;
}
}
}
return(taskData);
}
catch (Exception) { throw; }
}
public IEnumerable <object> Find(string Id)
{
try
{
List <PatientTaskData> tasksDataList = null;
List <IMongoQuery> queries = new List <IMongoQuery>();
queries.Add(Query.EQ(MEPatientTask.PatientGoalIdProperty, ObjectId.Parse(Id)));
queries.Add(Query.EQ(MEPatientTask.DeleteFlagProperty, false));
queries.Add(Query.EQ(MEPatientTask.TTLDateProperty, BsonNull.Value));
IMongoQuery mQuery = Query.And(queries);
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
List <MEPatientTask> meTasks = ctx.PatientTasks.Collection.Find(mQuery).ToList();
if (meTasks != null)
{
string goalName = string.Empty;
var mePG = ctx.PatientGoals.Collection.Find(Query.EQ(MEPatientGoal.IdProperty, ObjectId.Parse(Id))).SetFields(MEPatientGoal.NameProperty).FirstOrDefault();
if (mePG != null)
{
goalName = mePG.Name;
}
tasksDataList = new List <PatientTaskData>();
foreach (MEPatientTask t in meTasks)
{
PatientTaskData taskData = new PatientTaskData
{
Id = t.Id.ToString(),
TargetValue = t.TargetValue,
PatientGoalId = t.PatientGoalId.ToString(),
StatusId = ((int)t.Status),
TargetDate = t.TargetDate,
BarrierIds = Helper.ConvertToStringList(t.BarrierIds),
Description = t.Description,
StatusDate = t.StatusDate,
StartDate = t.StartDate,
CustomAttributes = DTOUtil.GetCustomAttributeIdAndValues(t.Attributes),
ClosedDate = t.ClosedDate,
CreatedById = t.RecordCreatedBy.ToString(),
DeleteFlag = t.DeleteFlag,
GoalName = goalName,
Details = t.Details
};
tasksDataList.Add(taskData);
}
}
}
return(tasksDataList);
}
catch (Exception) { throw; }
}
public GetInitializeTaskResponse GetInitialTask(GetInitializeTaskRequest request)
{
try
{
GetInitializeTaskResponse itr = new GetInitializeTaskResponse();
PatientTaskData ptd = (PatientTaskData)GoalsEndpointUtil.GetInitialTaskRequest(request);
PatientTask task = GoalsUtil.GetPatientTaskForInitialize(request, ptd);
itr.Task = task;
itr.Version = request.Version;
return(itr);
}
catch (Exception ex)
{
throw new Exception("AD:GetInitialTask()::" + ex.Message, ex.InnerException);
}
}
public object FindByID(string entityID)
{
try
{
PatientTaskData taskData = null;
List <IMongoQuery> queries = new List <IMongoQuery>();
queries.Add(Query.EQ(MEPatientTask.IdProperty, ObjectId.Parse(entityID)));
queries.Add(Query.EQ(MEPatientTask.DeleteFlagProperty, false));
queries.Add(Query.EQ(MEPatientTask.TTLDateProperty, BsonNull.Value));
IMongoQuery mQuery = Query.And(queries);
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
MEPatientTask t = ctx.PatientTasks.Collection.Find(mQuery).FirstOrDefault();
if (t != null)
{
taskData = new PatientTaskData
{
Id = t.Id.ToString(),
TargetValue = t.TargetValue,
PatientGoalId = t.PatientGoalId.ToString(),
StatusId = ((int)t.Status),
TargetDate = t.TargetDate,
BarrierIds = Helper.ConvertToStringList(t.BarrierIds),
Description = t.Description,
StatusDate = t.StatusDate,
StartDate = t.StartDate,
CustomAttributes = DTOUtil.GetCustomAttributeIdAndValues(t.Attributes),
ClosedDate = t.ClosedDate,
CreatedById = t.RecordCreatedBy.ToString(),
DeleteFlag = t.DeleteFlag,
Details = t.Details
};
var mePG = ctx.PatientGoals.Collection.Find(Query.EQ(MEPatientGoal.IdProperty, ObjectId.Parse(taskData.PatientGoalId))).SetFields(MEPatientGoal.NameProperty).FirstOrDefault();
if (mePG != null)
{
taskData.GoalName = mePG.Name;
}
}
}
return(taskData);
}
catch (Exception) { throw; }
}
public PutUpdateTaskResponse UpdatePatientTask(PutUpdateTaskRequest request)
{
try
{
PutUpdateTaskResponse result = new PutUpdateTaskResponse();
IGoalRepository repo = Factory.GetRepository(request, RepositoryType.PatientTask);
if (request.TaskIdsList != null && request.TaskIdsList.Count > 0)
{
List <PatientTaskData> ptd = (List <PatientTaskData>)repo.Find(request.PatientGoalId);
List <string> dbTaskIdList = GetTaskIds(ptd);
// update existing task entries with a delete
List <string> excludes = dbTaskIdList.Except(request.TaskIdsList).ToList <string>();
excludes.ForEach(ex =>
{
// create delete task request to insert
DeleteTaskDataRequest dtr = new DeleteTaskDataRequest {
TaskId = ex, UserId = request.UserId
};
repo.Delete(dtr);
});
}
if (request.Task != null && request.Task.Id != "0")
{
bool status = (bool)repo.Update(request);
if (status)
{
PatientTaskData data = repo.FindByID(request.Task.Id) as PatientTaskData;
result.TaskData = data;
}
}
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public object Initialize(object newEntity)
{
PutInitializeTaskRequest ptr = (PutInitializeTaskRequest)newEntity;
PatientTaskData task = null;
MEPatientTask pat = null;
try
{
pat = new MEPatientTask(this.UserId)
{
Id = ObjectId.GenerateNewId(),
PatientGoalId = ObjectId.Parse(ptr.PatientGoalId),
TTLDate = System.DateTime.UtcNow.AddDays(_initializeDays),
StatusDate = DateTime.UtcNow,
DeleteFlag = false
//,
//LastUpdatedOn = DateTime.UtcNow,
//UpdatedBy = ObjectId.Parse(this.UserId)
};
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
ctx.PatientTasks.Collection.Insert(pat);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientTask.ToString(),
pat.Id.ToString(),
Common.DataAuditType.Insert,
ptr.ContractNumber);
task = new PatientTaskData
{
Id = pat.Id.ToString()
};
}
return(task);
}
catch (Exception) { throw; }
}
public object Update(object entity)
{
bool result = false;
PutUpdateTaskRequest ptr = (PutUpdateTaskRequest)entity;
PatientTaskData pt = ptr.Task;
try
{
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
var q = MB.Query <MEPatientTask> .EQ(b => b.Id, ObjectId.Parse(pt.Id));
// Set the StatusDate to Now if the status is changed. Set the ClosedDate depending on the Status.
MEPatientTask existingPB = ctx.PatientTasks.Collection.Find(q).SetFields(MEPatientTask.StatusProperty).FirstOrDefault();
if (existingPB != null)
{
if ((int)existingPB.Status != pt.StatusId)
{
pt.StatusDate = DateTime.UtcNow;
}
if ((pt.StatusId == (int)GoalTaskStatus.Met || pt.StatusId == (int)GoalTaskStatus.Abandoned))
{
if (existingPB.Status != (GoalTaskStatus)pt.StatusId)
{
pt.ClosedDate = DateTime.UtcNow;
}
}
else
{
pt.ClosedDate = null;
}
}
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientTask.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientTask.VersionProperty, ptr.Version));
uv.Add(MB.Update.Set(MEPatientTask.LastUpdatedOnProperty, System.DateTime.UtcNow));
if (pt.Description != null)
{
uv.Add(MB.Update.Set(MEPatientTask.DescriptionProperty, pt.Description));
}
if (pt.Details != null)
{
uv.Add(MB.Update.Set(MEPatientTask.DetailProperty, pt.Details));
}
if (pt.StartDate != null)
{
uv.Add(MB.Update.Set(MEPatientTask.StartDateProperty, pt.StartDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientTask.StartDateProperty, BsonNull.Value));
}
if (pt.StatusDate != null)
{
uv.Add(MB.Update.Set(MEPatientTask.StatusDateProperty, pt.StatusDate));
}
if (pt.StatusId != 0)
{
uv.Add(MB.Update.Set(MEPatientTask.StatusProperty, pt.StatusId));
}
if (pt.TargetDate != null)
{
uv.Add(MB.Update.Set(MEPatientTask.TargetDateProperty, pt.TargetDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientTask.TargetDateProperty, BsonNull.Value));
}
if (pt.TargetValue != null)
{
uv.Add(MB.Update.Set(MEPatientTask.TargetValueProperty, pt.TargetValue));
}
if (pt.CustomAttributes != null)
{
uv.Add(MB.Update.SetWrapped <List <MAttribute> >(MEPatientTask.AttributesProperty, DTOUtil.GetAttributes(pt.CustomAttributes)));
}
if (pt.BarrierIds != null)
{
uv.Add(MB.Update.SetWrapped <List <ObjectId> >(MEPatientTask.BarriersProperty, DTOUtil.ConvertObjectId(pt.BarrierIds)));
}
if (pt.ClosedDate != null)
{
uv.Add(MB.Update.Set(MEPatientTask.ClosedDateProperty, pt.ClosedDate));
}
else
{
uv.Add(MB.Update.Set(MEPatientTask.ClosedDateProperty, BsonNull.Value));
}
uv.Add(MB.Update.Set(MEPatientTask.DeleteFlagProperty, pt.DeleteFlag));
if (pt.TemplateId != null)
{
uv.Add(MB.Update.Set(MEPatientTask.TemplateIdProperty, ObjectId.Parse(pt.TemplateId)));
}
DataAuditType type;
if (pt.DeleteFlag)
{
uv.Add(MB.Update.Set(MEPatientTask.TTLDateProperty, System.DateTime.UtcNow.AddDays(_expireDays)));
type = Common.DataAuditType.Delete;
}
else
{
uv.Add(MB.Update.Set(MEPatientTask.TTLDateProperty, BsonNull.Value));
type = Common.DataAuditType.Update;
}
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientTasks.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientTask.ToString(),
pt.Id,
type,
ptr.ContractNumber);
result = true;
}
return(result as object);
}
catch (Exception) { throw; }
}
internal static PatientTask GetPatientTaskForInitialize(GetInitializeTaskRequest request, PatientTaskData ptd)
{
PatientTask pt = null;
try
{
if (ptd != null)
{
pt = new PatientTask
{
CustomAttributes = GoalsEndpointUtil.GetAttributesLibraryByType(request, 2),
Id = ptd.Id,
StartDate = ptd.StartDate,
StatusId = ptd.StatusId,
TargetDate = ptd.TargetDate,
TargetValue = ptd.TargetValue,
DeleteFlag = ptd.DeleteFlag,
Details = ptd.Details
};
}
}
catch (Exception ex)
{
throw new Exception("AD:GetPatientTaskForInitialize()::" + ex.Message, ex.InnerException);
}
return(pt);
}
public bool PostUpdateTaskRequest(PostPatientGoalRequest request, PatientTaskData td)
{
throw new NotImplementedException();
}
