public object FindByExternalRecordId(string externalRecordId)
{
PatientSystemData data = null;
try
{
using (PatientSystemMongoContext ctx = new PatientSystemMongoContext(ContractDBName))
{
List <IMongoQuery> queries = new List <IMongoQuery>();
queries.Add(Query.EQ(MEPatientSystem.ExternalRecordIdProperty, externalRecordId));
queries.Add(Query.EQ(MEPatientSystem.DeleteFlagProperty, false));
queries.Add(Query.EQ(MEPatientSystem.TTLDateProperty, BsonNull.Value));
IMongoQuery mQuery = Query.And(queries);
MEPatientSystem mePS = ctx.PatientSystems.Collection.Find(mQuery).FirstOrDefault();
if (mePS != null)
{
data = new PatientSystemData
{
Id = mePS.Id.ToString(),
};
}
}
return(data);
}
catch (Exception) { throw; }
}
public PatientSystemData InsertPatientSystem(InsertPatientSystemDataRequest request)
{
PatientSystemData result = null;
try
{
if (request.PatientSystemsData != null)
{
var repo = Factory.GetRepository(RepositoryType.PatientSystem);
if (request.IsEngageSystem)
{
request.PatientSystemsData.SystemId = Constants.EngageSystemId;
request.PatientSystemsData.Value = EngageId.New();
request.PatientSystemsData.Primary = isSystemPrimary(Constants.EngageSystemId);
request.PatientSystemsData.StatusId = (int)Status.Active;
request.PatientSystemsData.DataSource = Constants.DataSource;
}
string id = (string)repo.Insert(request);
if (!string.IsNullOrEmpty(id))
{
result = (PatientSystemData)repo.FindByID(id);
}
}
return(result);
}
catch (Exception ex) { throw ex; }
}
public BulkInsertResult InsertBatchEngagePatientSystems(InsertBatchEngagePatientSystemsDataRequest request)
{
BulkInsertResult result = null;
try
{
if (request.PatientIds != null && request.PatientIds.Count > 0)
{
var repo = Factory.GetRepository(RepositoryType.PatientSystem);
List <PatientSystemData> psList = new List <PatientSystemData>();
bool status = isSystemPrimary(Constants.EngageSystemId);
List <string> patientIds = request.PatientIds;
patientIds.ForEach(p =>
{
PatientSystemData ps = new PatientSystemData
{
DataSource = Constants.DataSource,
PatientId = p,
Primary = status,
StatusId = (int)Status.Active,
SystemId = Constants.EngageSystemId,
Value = EngageId.New()
};
psList.Add(ps);
});
result = (BulkInsertResult)repo.InsertAll(psList.Cast <object>().ToList());
}
}
catch (Exception ex) { throw ex; }
return(result);
}
/// <summary>
/// Calls PatientSystem data domain to insert an Engage System record for the newly created patient.
/// </summary>
/// <param name="request">IDataDomainRequest object</param>
/// <returns>PatientSystemData object.</returns>
private PatientSystemData insertEngagePatientSystem(string patientId, IDataDomainRequest request)
{
PatientSystemData data = null;
try
{
InsertPatientSystemDataRequest psRequest = new InsertPatientSystemDataRequest
{
PatientId = patientId,
IsEngageSystem = true,
PatientSystemsData = new PatientSystemData {
PatientId = patientId
},
Context = request.Context,
ContractNumber = request.ContractNumber,
UserId = Constants.SystemContactId,// the requirement says that the engage Id should have createdby user as 'system'.
Version = request.Version
};
string DDPatientSystemServiceUrl = ConfigurationManager.AppSettings["DDPatientSystemServiceUrl"];
IRestClient client = new JsonServiceClient();
//[Route("/{Context}/{Version}/{ContractNumber}/Patient/{PatientId}/PatientSystem", "POST")]
string url = Helpers.BuildURL(string.Format("{0}/{1}/{2}/{3}/Patient/{4}/PatientSystem", DDPatientSystemServiceUrl, psRequest.Context, psRequest.Version, psRequest.ContractNumber, psRequest.PatientId), psRequest.UserId);
InsertPatientSystemDataResponse dataDomainResponse = client.Post <InsertPatientSystemDataResponse>(url, psRequest as object);
if (dataDomainResponse != null)
{
data = dataDomainResponse.PatientSystemData;
}
}
catch (Exception ex)
{
throw ex;
}
return(data);
}
public object FindByID(string entityID)
{
PatientSystemData data = null;
if (!string.IsNullOrEmpty(entityID))
{
}
return(data);
}
public object Insert(object newEntity)
{
InsertPatientSystemDataRequest request = newEntity as InsertPatientSystemDataRequest;
PatientSystemData data = request.PatientSystemsData;
string Id = null;
try
{
if (data != null)
{
if (string.IsNullOrEmpty(data.Value) || string.IsNullOrWhiteSpace(data.Value))
{
throw new ArgumentException("Patient System value is missing");
}
if (data.StatusId == 0)
{
throw new ArgumentException("Patient System status is missing");
}
using (PatientSystemMongoContext ctx = new PatientSystemMongoContext(ContractDBName))
{
MEPatientSystem mePS = new MEPatientSystem(this.UserId, data.CreatedOn)
{
PatientId = ObjectId.Parse(data.PatientId),
Value = Helper.TrimAndLimit(data.Value, 100),
Status = (Status)data.StatusId,
Primary = data.Primary,
SystemId = ObjectId.Parse(data.SystemId),
DataSource = Helper.TrimAndLimit(data.DataSource, 50),
DeleteFlag = false,
ExternalRecordId = data.ExternalRecordId,
LastUpdatedOn = data.UpdatedOn
};
ctx.PatientSystems.Collection.Insert(mePS);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientSystem.ToString(),
mePS.Id.ToString(),
DataAuditType.Insert,
request.ContractNumber);
Id = mePS.Id.ToString();
}
}
return(Id);
}
catch (Exception)
{
throw;
}
}
public PutPatientDataResponse InsertPatient(PutPatientDataRequest request)
{
IPatientRepository repo = Factory.GetRepository(request, RepositoryType.Patient);
PutPatientDataResponse result = repo.Insert(request) as PutPatientDataResponse;
if (!string.IsNullOrEmpty(result.Id))
{
//Create Engage system record for the newly created patient in PatientSystem collection.
PatientSystemData data = insertEngagePatientSystem(result.Id, request);
if (data != null)
{
result.EngagePatientSystemId = data.Id;
}
}
return(result);
}
public List <PatientSystemData> Select(List <string> Ids)
{
List <PatientSystemData> psList = null;
try
{
using (PatientSystemMongoContext ctx = new PatientSystemMongoContext(ContractDBName))
{
List <IMongoQuery> queries = new List <IMongoQuery>();
queries.Add(Query.In(MEPatientSystem.IdProperty, new BsonArray(Helper.ConvertToObjectIdList(Ids))));
queries.Add(Query.EQ(MEPatientSystem.DeleteFlagProperty, false));
queries.Add(Query.EQ(MEPatientSystem.TTLDateProperty, BsonNull.Value));
IMongoQuery mQuery = Query.And(queries);
List <MEPatientSystem> mePatients = ctx.PatientSystems.Collection.Find(mQuery).ToList();
if (mePatients != null && mePatients.Count > 0)
{
psList = new List <PatientSystemData>();
foreach (MEPatientSystem mePS in mePatients)
{
PatientSystemData data = new PatientSystemData
{
Id = mePS.Id.ToString(),
PatientId = mePS.PatientId.ToString(),
Value = mePS.Value,
StatusId = (int)mePS.Status,
Primary = mePS.Primary,
ExternalRecordId = mePS.ExternalRecordId,
SystemId = mePS.SystemId.ToString(),
DataSource = mePS.DataSource,
CreatedById = mePS.RecordCreatedBy.ToString(),
CreatedOn = mePS.RecordCreatedOn,
UpdatedById = mePS.UpdatedBy == null ? null : mePS.UpdatedBy.ToString(),
UpdatedOn = mePS.LastUpdatedOn
};
psList.Add(data);
}
}
}
return(psList);
}
catch (Exception) { throw; }
}
public object FindByID(string entityID)
{
PatientSystemData data = null;
try
{
using (PatientSystemMongoContext ctx = new PatientSystemMongoContext(ContractDBName))
{
List <IMongoQuery> queries = new List <IMongoQuery>();
queries.Add(Query.EQ(MEPatientSystem.IdProperty, ObjectId.Parse(entityID)));
queries.Add(Query.EQ(MEPatientSystem.DeleteFlagProperty, false));
queries.Add(Query.EQ(MEPatientSystem.TTLDateProperty, BsonNull.Value));
IMongoQuery mQuery = Query.And(queries);
MEPatientSystem mePS = ctx.PatientSystems.Collection.Find(mQuery).FirstOrDefault();
if (mePS != null)
{
data = new PatientSystemData
{
Id = mePS.Id.ToString(),
PatientId = mePS.PatientId.ToString(),
Value = mePS.Value,
StatusId = (int)mePS.Status,
Primary = mePS.Primary,
ExternalRecordId = mePS.ExternalRecordId,
SystemId = mePS.SystemId.ToString(),
DataSource = mePS.DataSource,
CreatedById = mePS.RecordCreatedBy.ToString(),
CreatedOn = mePS.RecordCreatedOn,
UpdatedById = mePS.UpdatedBy == null ? null : mePS.UpdatedBy.ToString(),
UpdatedOn = mePS.LastUpdatedOn
};
}
}
return(data);
}
catch (Exception) { throw; }
}
public List <PatientSystemData> UpdatePatientSystems(UpdatePatientSystemsDataRequest request)
{
List <PatientSystemData> dataList = null;
try
{
if (request.PatientSystemsData != null && request.PatientSystemsData.Count > 0)
{
dataList = new List <PatientSystemData>();
var repo = Factory.GetRepository(RepositoryType.PatientSystem);
request.PatientSystemsData.ForEach(p =>
{
UpdatePatientSystemDataRequest updateReq = new UpdatePatientSystemDataRequest
{
Id = p.Id,
PatientId = p.PatientId,
Context = request.Context,
ContractNumber = request.ContractNumber,
PatientSystemsData = p,
UserId = request.UserId,
Version = request.Version
};
bool success = (bool)repo.Update(updateReq);
if (success)
{
PatientSystemData result = (PatientSystemData)repo.FindByID(p.Id);
if (result != null)
{
dataList.Add(result);
}
}
});
}
return(dataList);
}
catch (Exception ex) { throw ex; }
}
public List <PatientSystemData> InsertPatientSystems(InsertPatientSystemsDataRequest request)
{
List <PatientSystemData> dataList = null;
try
{
if (request.PatientSystemsData != null && request.PatientSystemsData.Count > 0)
{
dataList = new List <PatientSystemData>();
var repo = Factory.GetRepository(RepositoryType.PatientSystem);
request.PatientSystemsData.ForEach(p =>
{
InsertPatientSystemDataRequest insertReq = new InsertPatientSystemDataRequest
{
PatientId = p.PatientId,
Context = request.Context,
ContractNumber = request.ContractNumber,
PatientSystemsData = p,
UserId = request.UserId,
Version = request.Version
};
string id = (string)repo.Insert(insertReq);
if (!string.IsNullOrEmpty(id))
{
PatientSystemData result = (PatientSystemData)repo.FindByID(id);
if (result != null)
{
dataList.Add(result);
}
}
});
}
return(dataList);
}
catch (Exception ex) { throw ex; }
}
public object Update(object entity)
{
UpdatePatientSystemDataRequest request = (UpdatePatientSystemDataRequest)entity;
PatientSystemData data = request.PatientSystemsData;
bool result = false;
try
{
if (data != null)
{
if (string.IsNullOrEmpty(data.Value) || string.IsNullOrWhiteSpace(data.Value))
{
throw new ArgumentException("Patient System value is missing");
}
if (data.StatusId == 0)
{
throw new ArgumentException("Patient System status is missing");
}
using (PatientSystemMongoContext ctx = new PatientSystemMongoContext(ContractDBName))
{
var q = MB.Query <MEPatientSystem> .EQ(b => b.Id, ObjectId.Parse(data.Id));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientSystem.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientSystem.VersionProperty, request.Version));
uv.Add(MB.Update.Set(MEPatientSystem.LastUpdatedOnProperty, System.DateTime.UtcNow));
if (!string.IsNullOrEmpty(data.PatientId))
{
uv.Add(MB.Update.Set(MEPatientSystem.PatientIdProperty, ObjectId.Parse(data.PatientId)));
}
uv.Add(MB.Update.Set(MEPatientSystem.ValueProperty, Helper.TrimAndLimit(data.Value, 100)));
if (!string.IsNullOrEmpty(data.DataSource))
{
uv.Add(MB.Update.Set(MEPatientSystem.DataSourceProperty, Helper.TrimAndLimit(data.DataSource, 50)));
}
else
{
uv.Add(MB.Update.Set(MEPatientSystem.DataSourceProperty, BsonNull.Value));
}
if (data.StatusId != 0)
{
uv.Add(MB.Update.Set(MEPatientSystem.StatusProperty, data.StatusId));
}
uv.Add(MB.Update.Set(MEPatientSystem.PrimaryProperty, data.Primary));
if (!string.IsNullOrEmpty(data.SystemId))
{
uv.Add(MB.Update.Set(MEPatientSystem.SystemIdProperty, ObjectId.Parse(data.SystemId)));
}
IMongoUpdate update = MB.Update.Combine(uv);
WriteConcernResult res = ctx.PatientSystems.Collection.Update(q, update);
if (res.Ok == false)
{
throw new Exception("Failed to update a patient system: " + res.ErrorMessage);
}
else
{
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientSystem.ToString(),
data.Id,
DataAuditType.Update,
request.ContractNumber);
}
result = true;
}
}
return(result);
}
catch (Exception) { throw; }
}
