public DTO.Program FindByName(string entityName)
{
try
{
DTO.Program result = null;
using (ProgramMongoContext ctx = new ProgramMongoContext(_dbName))
{
var findcp = MB.Query <MEProgram> .EQ(b => b.Name, entityName);
MEProgram cp = ctx.Programs.Collection.Find(findcp).FirstOrDefault();
if (cp != null)
{
result = new DTO.Program
{
ProgramID = cp.Id.ToString()
};
}
else
{
throw new ArgumentException("ProgramName is not valid or is missing from the records.");
}
}
return(result);
}
catch (Exception ex)
{
throw new Exception("DD:PatientProgramRepository:FindByName()::" + ex.Message, ex.InnerException);
}
}
public object GetLimitedProgramFields(string objectId)
{
try
{
MEProgram cp = null;
using (ProgramMongoContext ctx = new ProgramMongoContext(_dbName))
{
var query = MB.Query.And(
MB.Query <MEProgram> .EQ(b => b.Id, ObjectId.Parse(objectId)),
MB.Query <MEProgram> .EQ(b => b.DeleteFlag, false)
);
cp = ctx.Programs.Collection.Find(query).SetFields(
MEProgram.AuthoredByProperty,
MEProgram.TemplateNameProperty,
MEProgram.TemplateVersionProperty,
MEProgram.ProgramVersionProperty,
MEProgram.ProgramVersionUpdatedOnProperty,
MEProgram.ObjectivesInfoProperty
).FirstOrDefault();
}
return(cp);
}
catch (Exception ex)
{
throw new Exception("DD:Program:GetLimitedProgramFields()::" + ex.Message, ex.InnerException);
}
}
public List <Module> GetProgramModules(ObjectId progId)
{
try
{
List <Module> mods = null;
using (ProgramMongoContext ctx = new ProgramMongoContext(_dbName))
{
var findcp = MB.Query <MEProgram> .EQ(b => b.Id, progId);
MEProgram cp = ctx.Programs.Collection.Find(findcp).FirstOrDefault();
if (cp != null)
{
mods = cp.Modules;
}
else
{
throw new ArgumentException("ProgramId is not valid or is missing from the records.");
}
}
return(mods);
}
catch (Exception ex)
{
throw new Exception("DD:PatientProgramRepository:GetProgramModules()::" + ex.Message, ex.InnerException);
}
}
public void Get_With_Two_Objectives_Test()
{
StubProgramRepositoryFactory factory = new StubProgramRepositoryFactory();
GetPatientProgramsDataRequest request = new GetPatientProgramsDataRequest
{
ContractNumber = "InHealth001",
Context = "NG",
UserId = "000000000000000000000000"
};
IProgramRepository repo = factory.GetRepository(request, RepositoryType.Program);
MEProgram mep = repo.GetLimitedProgramFields("000000000000000000000000") as MEProgram;
Assert.AreEqual(2, mep.Objectives.Count);
}
public void Get_With_Objectives_Test()
{
string ctrl = "123456789011111111112223";
StubProgramRepositoryFactory factory = new StubProgramRepositoryFactory();
GetPatientProgramsDataRequest request = new GetPatientProgramsDataRequest
{
ContractNumber = "InHealth001",
Context = "NG",
UserId = "000000000000000000000000"
};
IProgramRepository repo = factory.GetRepository(request, RepositoryType.Program);
MEProgram mep = repo.GetLimitedProgramFields("000000000000000000000000") as MEProgram;
Assert.IsNotNull(mep.Objectives);
}
public MEProgram GetLimitedProgramDetails(string objectId, Interface.IDataDomainRequest request)
{
MEProgram mep = new MEProgram(request.UserId)
{
AuthoredBy = "123456789012345678901234",
TemplateName = "template stub name",
TemplateVersion = "1.0",
ProgramVersion = "1.0",
ProgramVersionUpdatedOn = System.DateTime.UtcNow,
Objectives = new List <Objective> {
new Objective {
Id = ObjectId.GenerateNewId(), Status = Status.Active, Units = "lbs", Value = "134"
}
}
};
return(mep);
}
public object FindByID(string entityID)
{
try
{
MEProgram cp = null;
using (ProgramMongoContext ctx = new ProgramMongoContext(_dbName))
{
var findcp = MB.Query <MEProgram> .EQ(b => b.Id, ObjectId.Parse(entityID));
cp = ctx.Programs.Collection.Find(findcp).FirstOrDefault();
}
return(cp);
}
catch (Exception ex)
{
throw new Exception("DD:Program:FindByID()::" + ex.Message, ex.InnerException);
}
}
public object GetLimitedProgramFields(string objectId)
{
MEProgram mep = new MEProgram(this.userId)
{
AuthoredBy = "123456789012345678901234",
TemplateName = "template stub name",
TemplateVersion = "1.0",
ProgramVersion = "1.0",
ProgramVersionUpdatedOn = System.DateTime.UtcNow,
Objectives = new List <Objective> {
new Objective {
Id = ObjectId.GenerateNewId(), Status = Status.Active, Units = "lbs", Value = "134"
},
new Objective {
Id = ObjectId.GenerateNewId(), Status = Status.Inactive, Units = "oz", Value = "55"
}
}
};
return(mep);
}
public MEPatientProgram CreateInitialMEPatientProgram(DTO.PutProgramToPatientRequest request, MEProgram cp, List <global::MongoDB.Bson.ObjectId> sil)
{
throw new NotImplementedException();
}
public string GetCareManagerValueByRule(DTO.PutProgramToPatientRequest request, MEProgram cp)
{
throw new NotImplementedException();
}
public void HydrateResponsesInProgram(MEProgram prog, List <MEResponse> responseList, string usrId)
{
throw new NotImplementedException();
}
public List <MEResponse> GetProgramResponseslist(List <global::MongoDB.Bson.ObjectId> idl, MEProgram cp, DTO.PutProgramToPatientRequest request)
{
throw new NotImplementedException();
}
public PutProgramToPatientResponse PutPatientToProgram(PutProgramToPatientRequest request)
{
try
{
PutProgramToPatientResponse response = new PutProgramToPatientResponse();
response.Outcome = new Phytel.API.DataDomain.Program.DTO.Outcome();
#region validation calls
if (!IsValidPatientId(request))
{
return(FormatExceptionResponse(response, "Patient does not exist or has an invalid id.", "500"));
}
if (!IsValidContractProgramId(request))
{
return(FormatExceptionResponse(response, "ContractProgram does not exist or has an invalid identifier.", "500"));
}
if (!IsContractProgramAssignable(request))
{
return(FormatExceptionResponse(response, "ContractProgram is not currently active.", "500"));
}
#endregion
/**********************************/
List <MEPatientProgram> pp = DTOUtility.FindExistingpatientProgram(request);
if (!DTOUtility.CanInsertPatientProgram(pp))
{
response.Outcome.Result = 0;
response.Outcome.Reason = pp[0].Name + " is already assigned or reassignment is not allowed";
}
else
{
MEProgram cp = DTOUtility.GetProgramForDeepCopy(request);
var stepIdList = new List <ObjectId>();
List <MEResponse> responseList = DTOUtility.GetProgramResponseslist(stepIdList, cp, request);
DTOUtils.HydrateResponsesInProgram(cp, responseList, request.UserId);
MEPatientProgram nmePp = DTOUtility.CreateInitialMEPatientProgram(request, cp, stepIdList);
DTOUtility.InitializePatientProgramAssignment(request, nmePp);
List <MEPatientProgramResponse> pprs = DTOUtils.ExtractMEPatientProgramResponses(nmePp, request.ContractNumber, request.UserId);
ProgramInfo pi = DTOUtility.SaveNewPatientProgram(request, nmePp);
if (pi != null)
{
response.program = pi;
DTOUtility.SavePatientProgramResponses(pprs, request);
DTOUtility.InitializeProgramAttributes(request, response);
}
response.Outcome.Result = 1;
response.Outcome.Reason = "Successfully assigned this program for the individual";
}
return(response);
}
catch (Exception ex)
{
throw new Exception("DD:DataProgramManager:PutPatientToProgram()::" + ex.Message, ex.InnerException);
}
}
public GetProgramDetailsSummaryResponse GetPatientProgramDetailsById(GetProgramDetailsSummaryRequest request)
{
try
{
GetProgramDetailsSummaryResponse response = new GetProgramDetailsSummaryResponse();
IProgramRepository repo = Factory.GetRepository(request, RepositoryType.PatientProgram);
MEPatientProgram mepp = repo.FindByID(request.ProgramId) as MEPatientProgram;
IProgramRepository respRepo = Factory.GetRepository(request, RepositoryType.PatientProgramResponse);
var stepIds = mepp.Modules.SelectMany(m => m.Actions.SelectMany(a => a.Steps.Select(s => s.Id))).ToList();
DTOUtility.ResponsesBag = respRepo.Find(stepIds).Cast <MEPatientProgramResponse>().ToList();
response.Program = new ProgramDetail
{
Id = mepp.Id.ToString(),
Client = mepp.Client != null?mepp.Client.ToString() : null,
ContractProgramId = mepp.ContractProgramId.ToString(),
Description = mepp.Description,
Name = mepp.Name,
PatientId = mepp.PatientId.ToString(),
//ProgramState = (int)mepp.ProgramState, depricated - Use Element state instead.
ShortName = mepp.ShortName,
StartDate = mepp.StartDate,
EndDate = mepp.EndDate,
AttrStartDate = mepp.AttributeStartDate,
AttrEndDate = mepp.AttributeEndDate,
Status = (int)mepp.Status,
Version = mepp.Version,
Completed = mepp.Completed,
Enabled = mepp.Enabled,
Next = mepp.Next != null?mepp.Next.ToString() : string.Empty,
Order = mepp.Order,
Previous = mepp.Previous != null?mepp.Previous.ToString() : string.Empty,
SourceId = mepp.SourceId.ToString(),
AssignBy = mepp.AssignedBy.ToString(),
AssignDate = mepp.AssignedOn,
AssignTo = mepp.AssignedTo.ToString(),
ElementState = (int)mepp.State,
StateUpdatedOn = mepp.StateUpdatedOn,
CompletedBy = mepp.CompletedBy,
DateCompleted = mepp.DateCompleted,
EligibilityEndDate = mepp.EligibilityEndDate,
EligibilityStartDate = mepp.EligibilityStartDate,
EligibilityRequirements = mepp.EligibilityRequirements,
AuthoredBy = mepp.AuthoredBy,
//ObjectivesData = DTOUtils.GetObjectives(mepp.Objectives),
SpawnElement = DTOUtility.GetSpawnElement(mepp),
Modules = DTOUtility.GetModules(mepp.Modules, mepp.ContractProgramId.ToString(), request)
};
// load program attributes
ProgramAttributeData pad = GetProgramAttributes(mepp.Id.ToString(), request);
response.Program.Attributes = pad;
// Get the fields from Program collection.
MEProgram meProgram = DTOUtility.GetLimitedProgramDetails(mepp.SourceId.ToString(), request);
if (meProgram != null)
{
response.Program.AuthoredBy = meProgram.AuthoredBy;
response.Program.TemplateName = meProgram.TemplateName;
response.Program.TemplateVersion = meProgram.TemplateVersion;
response.Program.ProgramVersion = meProgram.ProgramVersion;
response.Program.ProgramVersionUpdatedOn = meProgram.ProgramVersionUpdatedOn;
response.Program.ObjectivesData = DTOUtility.GetObjectivesData(meProgram.Objectives);
}
return(response);
}
catch (Exception ex)
{
throw new Exception("DD:DataProgramManager:GetPatientProgramDetailsById()::" + ex.Message, ex.InnerException);
}
finally
{
DTOUtility.ResponsesBag = null;
}
}
