public HttpStatusCode Update(string patid, String format, String data)
{
int id = Int32.Parse(patid);
var resource = Parse(format, data);
var patient = PatientMapper.MapResource(resource);
patient.PatientId = id;
// Upate "Patient" resource in the repository
_repository.UpdatePatient(patient);
var response = WebOperationContext.Current.OutgoingResponse;
var uri = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.BaseUri;
string fhirbase = uri.AbsoluteUri;
string host = uri.Host;
response.LastModified = patient.Timestamp;
response.StatusCode = HttpStatusCode.Created;
response.Headers.Add("Host", host);
response.Location = String.Format("{0}/Patient/{1}/_history/{2}", fhirbase, patient.PatientId, patient.Version);
return(HttpStatusCode.OK);
}
public void Create(PatientDTO item)
{
var patient = PatientMapper.DTOtoPatient(item);
_context.Patients.Add(patient);
_context.SaveChanges();
}
public void Map_patient_persistance_collection_to_patient_entity_collection_when_collection_is_null()
{
List <PatientPersistence> listOfPatientPersistance = null;
Assert.Throws <ArgumentNullException>(()
=> PatientMapper.MapPatientPersistenceCollectionToPatientEntityCollection(listOfPatientPersistance));
}
public IEnumerable <Patient> GetAllPatients()
{
using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext))
{
return(PatientMapper.MapPatientPersistenceCollectionToPatientEntityCollection(_context.Patients.ToList()));
}
}
private void btnAjouter_Click(object sender, EventArgs e)
{
PatientMapper pM = new PatientMapper();
Patient p = new Patient
{
NuméroAssuranceMaladie = txtNAS.Text,
Nom = txtNomPatient.Text,
Prénom = txtPrenomPatient.Text,
Adresse = txtAdressePatient.Text,
NuméroTéléphone = txtTelephonePatient.Text,
DateNaissance = dateNaissance.Value
};
if (pM.Insert(p) > 0)
{
System.Windows.Forms.MessageBox.Show("Succès ! Patient ajouté !");
var dlgPati = (PATI01)Tag;
dlgPati.Show();
Close();
dlgPati.search("", "");
}
else
{
System.Windows.Forms.MessageBox.Show("Erreur ! Patient non ajouté !");
}
}
public void Map_patient_persistence_to_patient_entity_when_patient_persistance_is_null()
{
Patient patient = null;
Assert.Throws <ArgumentNullException>(()
=> PatientMapper.MapPatientEntityToPatientIdentifierDTO(patient));
}
private String Serialize(iSOFT.ANZ.PatientManagerServiceLibrary.Patient iPMpatient)
{
var resource = PatientMapper.MapModel(iPMpatient);
String payload = String.Empty;
if (WebOperationContext.Current != null)
{
var response = WebOperationContext.Current.OutgoingResponse;
response.LastModified = iPMpatient.ModifDttm;
string accept = WebOperationContext.Current.IncomingRequest.Accept;
if (!String.IsNullOrEmpty(accept) && accept == "application/json")
{
payload = FhirSerializer.SerializeResourceToJson(resource);
response.ContentType = "application/json+fhir";
}
else
{
payload = FhirSerializer.SerializeResourceToXml(resource);
response.ContentType = "application/xml+fhir";
}
}
return(payload);
}
private void btnModifierPatient_Click(object sender, EventArgs e)
{
if (btnModifierPatient.Text == "Modifier")
{
btnModifierPatient.Text = "Confirmer";
enabled(true);
lbPatients.Enabled = false;
btnAjouterPatient.Enabled = false;
}
else if (btnModifierPatient.Text == "Confirmer")
{
btnModifierPatient.Text = "Modifier";
enabled(false);
lbPatients.Enabled = true;
btnAjouterPatient.Enabled = true;
PatientMapper pM = new PatientMapper();
Patient p = new Patient
{
NuméroAssuranceMaladie = txtNAS.Text,
Nom = txtNomPatients.Text,
Prénom = txtPrenomPatient.Text,
Adresse = txtAdressePatient.Text,
NuméroTéléphone = txtTelephonePatient.Text,
DateNaissance = dateNaissance.Value
};
pM.Delete(lp[lbPatients.SelectedIndex]);
pM.Insert(p);
search(txtRechercheNom.Text, txtRecherchePrenom.Text);
}
}
public IActionResult GetMaliciousPatients()
{
List <Patient> patients = _patientService.GetPatientsThatShouldBeBlocked();
List <MaliciousPatientDTO> maliciousPatients = PatientMapper.ListPatientToListMaliciousPatient(patients);
return(Ok(maliciousPatients));
}
public void Map_patient_persistence_to_patient_entity_when_patient_persistance_is_null()
{
PatientPersistence patientPersistance = null;
Assert.Throws <ArgumentNullException>(()
=> PatientMapper.MapPatientPersistenceToPatientEntity(patientPersistance));
}
public List <PatientDTO> GetAll()
{
var patients = _context.Patients
.Select(p => PatientMapper.PatientToDTO(p))
.ToList();
return(patients);
}
public void Map_patient_entity_to_patient_identifier_dto()
{
Patient patient = this.GetPatient();
IdentifiableDTO <PatientDTO> patientDTO = PatientMapper.MapPatientEntityToPatientIdentifierDTO(patient);
Assert.True(IsEqualPatientPersistanceAndPatientEntity(patientDTO, patient));
}
public IActionResult CreatePatient([FromBody] CreatePatientViewModel createPatientViewModel)
{
var patientDTO = PatientMapper.CreatePatientVMToDTO(createPatientViewModel);
_service.Create(patientDTO);
return(Ok(ModelState));
}
public Patient GetPatientById(Guid id)
{
using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext))
{
var patient = _context.Patients.Include("DoctorPersistance").SingleOrDefault(c => c.Id.Equals(id));
return(PatientMapper.MapPatientPersistenceToPatientEntity(patient));
}
}
public void Map_patient_persistence_to_patient_entity()
{
PatientPersistence patientPersistence = this.GetPatientPersistence();
Patient patient = PatientMapper.MapPatientPersistenceToPatientEntity(patientPersistence);
Assert.True(IsEqualPatientPersistanceAndPatientEntity(patientPersistence, patient));
}
private IList <IDictionary <string, string> > Retrieve(Patient patient)
{
var patientInfo = PatientMapper.MapToGETData(patient);
var restUrl = "/patients";
JToken action = api.GET(restUrl, patientInfo);
return(GetSearchResults(action));
}
private string Update(Patient patient)
{
var putData = PatientMapper.MapToPUTData(patient);
var restUrl = string.Format("/patients/{0}", patient.ID);
JToken action = api.PUT(restUrl, putData);
return(GetUpdateResults(action));
}
private CreatePatientResult Create(Patient patient, string departmentID)
{
var postData = PatientMapper.MapToPOSTData(patient, departmentID);
var restUrl = "/patients";
JToken action = api.POST(restUrl, postData);
return(GetCreateResults(action));
}
public void Map_patient_persistance_collection_to_patient_entity_collection()
{
List <PatientPersistence> patientPersistences = this.GetListOfPatientPersistance();
List <Patient> listOfPatients = PatientMapper.MapPatientPersistenceCollectionToPatientEntityCollection(patientPersistences).ToList();
Assert.True(this.IsEqualPatientPersistanceAndPatientEntity(patientPersistences[0], listOfPatients[0]));
Assert.True(this.IsEqualPatientPersistanceAndPatientEntity(patientPersistences[1], listOfPatients[1]));
}
/// <summary>
/// Get all patients of a given Practitioner
/// </summary>
/// <param name="practitionerId"></param>
/// <returns> a list of Patients </returns>
public static async Task <List <Models.Patient> > GetPatientsOfPractitioner(string practitionerId)
{
List <Models.Patient> patientList = new List <Models.Patient>();
SortedSet <string> patientIdList = new SortedSet <string>();
try
{
var encounterQuery = new SearchParams()
.Where("participant.identifier=http://hl7.org/fhir/sid/us-npi|" + practitionerId)
.Include("Encounter.participant.individual")
.Include("Encounter.patient")
.LimitTo(LIMIT_ENTRY);
Bundle Result = await Client.SearchAsync <Encounter>(encounterQuery);
// implement paging for HAPI FHIR API Bundle
while (Result != null)
{
foreach (var Entry in Result.Entry)
{
// Get patient id and add to a list
Encounter encounter = (Encounter)Entry.Resource;
string patientRef = encounter.Subject.Reference;
string patientId = patientRef.Split('/')[1];
patientIdList.Add(patientId);
}
Result = Client.Continue(Result, PageDirection.Next);
}
// fetch patient data from the list of patient ids
foreach (var patientId in patientIdList)
{
Bundle PatientResult = await Client.SearchByIdAsync <Hl7.Fhir.Model.Patient>(patientId);
if (PatientResult.Entry.Count > 0)
{
// Map the FHIR Patient object to App's Patient object
Hl7.Fhir.Model.Patient fhirPatient = (Hl7.Fhir.Model.Patient)PatientResult.Entry[0].Resource;
PatientMapper mapper = new PatientMapper();
Models.Patient patient = mapper.Map(fhirPatient);
patientList.Add(patient);
}
}
}
catch (FhirOperationException FhirException)
{
System.Diagnostics.Debug.WriteLine("Fhir error message: " + FhirException.Message);
}
catch (Exception GeneralException)
{
System.Diagnostics.Debug.WriteLine("General error message: " + GeneralException.Message);
}
return(patientList);
}
public ActionResult <PatientViewModel> GetPatient(int id)
{
var patientDTO = _service.Get(id);
if (patientDTO is null)
{
return(NotFound());
}
return(PatientMapper.DTOtoPatientVM(patientDTO));
}
public PatientDTO Get(int id)
{
var patient = _context.Patients.Include(p => p.MedicalChart).SingleOrDefault(p => p.Id.Equals(id));
if (patient is null)
{
return(null);
}
return(PatientMapper.PatientToDTO(patient));
}
public ActionResult GetPatientByPatientCardId(int patientCardId)
{
try
{
Patient patient = _patientService.GetPatientByPatientCardId(patientCardId);
return(Ok(PatientMapper.PatientToPatientBasicDTO(patient)));
}
catch (NotFoundException exception)
{
return(NotFound(exception.Message));
}
}
public IServiceResult Create(IServiceInput input)
{
var vm = input as CreatePatientVM;
// map patient
Patient patient = CreatePatientVMMapper.MapToPatient(vm);
// call core method
CreatePatientResult retval = Create(patient, vm.DepartmentID);
// return mapped result
return(PatientMapper.MapToCreatePatientVM(patient, retval));
}
public IServiceResult Search(IServiceInput input)
{
var vm = input as SearchForPatientVM;
// map patient
var patient = SearchForPatientVMMapper.MapToPatient(vm);
// call core method
var retval = Retrieve(patient);
//return mapped result
return(PatientMapper.MapToSearchForPatientVM(retval));
}
public IServiceResult Update(IServiceInput input)
{
var vm = input as UpdatePatientVM;
// map patient
var patient = UpdatePatientVMMapper.MapToPatient(vm);
// call core method
var retval = Update(patient);
// return mapped result
return(PatientMapper.MapToUpdatePatientVM(retval));
}
public GridViewModel GetSearchResult(SearchRequest request)
{
var model = PatientMapper.CreateGridViewModel();
var getAllPatient = _repository.GetContext().Patients
.Where(p => !p.IsArchived);
var pageResult = QueryListHelper.SortResults(getAllPatient, request);
var serviceRows = pageResult
.Select(PatientMapper.BindGridData);
model.Rows = serviceRows.ToPagedList(request.Page ?? 1, request.PageSize);
return(model);
}
public IdentifiableDTO <PatientDTO> GetById(Guid id)
{
try
{
return(PatientMapper.MapPatientEntityToPatientIdentifierDTO(_patientRepository.GetById(id)));
}
catch (ArgumentNullException e)
{
throw new NotFoundEntityException();
}
catch (Exception e)
{
throw new InternalServerErrorException();
}
}
public GridViewModel GetSearchResult(SearchRequest request)
{
var model = PatientMapper.CreateGridViewModel();
var getAllPatient = _repository.GetContext().Patients
.Include(p => p.Gender)
.Where(p => !p.IsArchived);
var pageResult = QueryListHelper.SortResults(getAllPatient, request);
var serviceRows = pageResult
.Where(p => string.IsNullOrEmpty(request.SearchText) || p.GetDisplayName().ToLowerInvariant().Contains(request.SearchText.ToLowerInvariant()))
.Select(PatientMapper.BindGridData);
model.Rows = serviceRows.ToPagedList(request.Page ?? 1, request.PageSize);
return(model);
}
public HttpResponseMessage Create(Hl7.Fhir.Model.Patient fhirPatient)
{
HttpResponseMessage message = new HttpResponseMessage();
Patient patient = PatientMapper.MapResource(fhirPatient);
patient = (Patient)ControllerUtils.AddMetadata(patient, ControllerUtils.CREATE);
db.Patients.Add(patient);
db.SaveChanges();
message.Content = new StringContent("Patient created!", Encoding.UTF8, "text/html");
message.StatusCode = HttpStatusCode.Created;
message.Headers.Location = new Uri(Url.Link("SpecificPatient", new { id = patient.PatientId }));
return(message);
}
public PatientCardService()
{
this.pm = new PatientMapper();
}
