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; }
}
/// <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 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 InsertPatientSystemDataResponse Post(InsertPatientSystemDataRequest request)
{
InsertPatientSystemDataResponse response = new InsertPatientSystemDataResponse();
try
{
RequireUserId(request);
response.PatientSystemData = Manager.InsertPatientSystem(request);
response.Version = request.Version;
}
catch (Exception ex)
{
RaiseException(response, ex);
}
return(response);
}
public InsertPatientSystemDataResponse InsertPatientSystem(InsertPatientSystemDataRequest request)
{
//[Route("/{Context}/{Version}/{ContractNumber}/Patient/{PatientId}/PatientSystem", "POST")]
Uri theUriPS = new Uri(string.Format("{0}/PatientSystem/{1}/{2}/{3}/Patient/{4}/PatientSystem?UserId={5}",
Url,
Context,
Version,
ContractNumber,
request.PatientId,
HeaderUserId));
HttpClient clientPS = GetHttpClient(theUriPS);
DataContractJsonSerializer jsonSerPS = new DataContractJsonSerializer(typeof(InsertPatientSystemDataRequest));
// use the serializer to write the object to a MemoryStream
MemoryStream msPS = new MemoryStream();
jsonSerPS.WriteObject(msPS, request);
msPS.Position = 0;
//use a Stream reader to construct the StringContent (Json)
StreamReader srPS = new StreamReader(msPS);
StringContent theContentPS = new StringContent(srPS.ReadToEnd(), System.Text.Encoding.UTF8, "application/json");
msPS.Dispose();
//Post the data
var responsePS = clientPS.PostAsync(theUriPS, theContentPS);
var responseContentPS = responsePS.Result.Content;
string responseStringPS = responseContentPS.ReadAsStringAsync().Result;
InsertPatientSystemDataResponse responsePatientPS = null;
using (var msResponsePS = new MemoryStream(Encoding.Unicode.GetBytes(responseStringPS)))
{
var serializerPS = new DataContractJsonSerializer(typeof(InsertPatientSystemDataResponse));
responsePatientPS = (InsertPatientSystemDataResponse)serializerPS.ReadObject(msResponsePS);
}
return(responsePatientPS);
}
public void InsertPatientSystem_Test()
{
InsertPatientSystemDataRequest request = new InsertPatientSystemDataRequest
{
Context = context,
ContractNumber = contractNumber,
UserId = userId,
Version = version,
PatientSystemsData = new PatientSystemData {
PatientId = "55a57abd84ac072348fb7664"
},
PatientId = "55a57abd84ac072348fb7664",
IsEngageSystem = true
};
//[Route("/{Context}/{Version}/{ContractNumber}/Patient/{PatientId}/PatientSystem", "POST")]
InsertPatientSystemsDataResponse response = client.Post <InsertPatientSystemsDataResponse>(string.Format("{0}/{1}/{2}/{3}/Patient/{4}/PatientSystem", url, context, version, contractNumber, request.PatientId), request);
Assert.IsNotNull(response);
}
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 PatientSystemData InsertPatientSystem(InsertPatientSystemDataRequest request)
{
throw new NotImplementedException();
}
