public IActionResult UpdatePatient(int id, [FromBody] PatientDTO pat)
{
if (pat == null)
{
return(BadRequest());
}
if (pat.Lastname == string.Empty)
{
ModelState.AddModelError("Name/FirstName", "The last name or first name shouldn't be empty");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var patToUpdate = _patientRepository.GetPatientByMRN(pat.MRN);
if (patToUpdate == null)
{
return(NotFound());
}
_patientRepository.UpdateAccount(pat);
return(NoContent()); //success
}
public PatientDTO UpdatePatientStatusByID(string ID, string statusID)
{
StoreContext db = new StoreContext();
Patient patient = db.Patient
.Where(s => s.PatientId == Helper.DecryptInt(ID))
.Include(u => u.User)
.Include(b => b.BloodType)
.Include(s => s.Status)
.FirstOrDefault();
if (patient != null)
{
patient.StatusId = Helper.DecryptInt(statusID);
db.SaveChanges();
PatientDTO response = mapper.Map <PatientDTO>(patient);
return(response);
}
else
{
return(null);
}
}
public string AddPatients(PatientDTO patient)
{
using (var dbcxtransaction = _tandVardContext.Database.BeginTransaction())
{
var tblInsertItem = new TblPatient()
{
FldFirstName = patient.FldFirstName,
FldLastName = patient.FldLastName,
FldAddress = patient.FldAddress,
FldEmail = patient.FldEmail,
FldSSnumber = patient.FldSSnumber,
FldPhoneNumber = patient.FldPhoneNumber
};
var result = _tandVardContext.TblPatients.Add(tblInsertItem);
if (result.State.ToString() == "Added")
{
_tandVardContext.SaveChanges();
dbcxtransaction.Commit();
return("New patient created");
}
else
{
throw new Exception("Something went wrong");
}
}
}
public PatientDTO FindPatientByPersonalID(string personalID)
{
StoreContext db = new StoreContext();
if (personalID != null)
{
Patient patient = db.Patient
.Where(s => s.Idnumber == personalID)
.Include(u => u.User)
.Include(b => b.BloodType)
.Include(s => s.Status)
.FirstOrDefault();
if (patient != null)
{
PatientDTO response = mapper.Map <PatientDTO>(patient);
return(response);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public PatientDTO CreatePatient(PatientCreateDTO info)
{
StoreContext db = new StoreContext();
Patient patient = mapper.Map <Patient>(info);
Patient test = db.Patient.Where(u => u.Idnumber == info.Idnumber).FirstOrDefault();
if (patient != null && test == null)
{
db.Patient.Add(patient);
db.SaveChanges();
Patient patientResponse = db.Patient
.Where(s => s.PatientId == patient.PatientId)
.Include(u => u.User)
.Include(b => b.BloodType)
.Include(s => s.Status)
.FirstOrDefault();
PatientDTO response = mapper.Map <PatientDTO>(patientResponse);
return(response);
}
else
{
return(null);
}
}
public PatientDTO FindPatientByID(string ID)
{
StoreContext db = new StoreContext();
if (ID != null)
{
Patient patient = db.Patient
.Where(s => s.PatientId == Helper.DecryptInt(ID))
.Include(u => u.User)
.Include(b => b.BloodType)
.Include(s => s.Status)
.FirstOrDefault();
if (patient != null)
{
PatientDTO response = mapper.Map <PatientDTO>(patient);
return(response);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public async Task <ActionResult <PatientDTO> > AddPatient(PatientDTO dto)
{
if (ModelState.IsValid)
{
var patient = _mapper.Map <Patient>(dto);
using (var trans = _context.Database.BeginTransaction())
{
_context.Patients.Add(patient);
await _context.SaveChangesAsync();
await _sender.SendMessage(new MessagePayload
{
EmailAddress = dto.Email ?? "*****@*****.**",
Message = "Powiadomienie o kwarantannie.",
Title = "COVID-19"
});
await trans.CommitAsync();
return(CreatedAtAction(nameof(GetPatient), new { id = patient.Id }, patient));
}
}
return(BadRequest());
}
public IActionResult AddPatient(PatientDTO patientDTO)
{
var userServiceClient = new RestClient(_serviceSettings.UserServiceUrl);
var userServiceRequest = new RestRequest("/api/patient/", Method.POST);
userServiceRequest.AddJsonBody(new
{
Name = patientDTO.Name,
Surname = patientDTO.Surname,
Jmbg = patientDTO.Jmbg,
Gender = patientDTO.Gender,
DateOfBirth = patientDTO.DateOfBirth,
Phone = patientDTO.Phone,
CityId = patientDTO.CityZipCode,
HomeAddress = patientDTO.HomeAddress,
Email = patientDTO.Email,
Password = patientDTO.Password,
ImageName = "/images/Blank-profile.png"
});
var response = userServiceClient.Execute(userServiceRequest);
if (response.StatusCode != HttpStatusCode.NoContent)
{
return(new ContentResult()
{
StatusCode = (int)response.StatusCode,
Content = response.Content,
ContentType = response.ContentType
});
}
var patientServiceClient = new RestClient(_serviceSettings.PatientServiceUrl);
var patientServiceRequest = new RestRequest("/api/patient/" + patientDTO.Jmbg + "/medical-info",
Method.PUT);
patientServiceRequest.AddJsonBody(new
{
BloodType = patientDTO.BloodType,
RhFactor = patientDTO.RhFactor,
Allergies = patientDTO.Allergies,
MedicalHistory = patientDTO.MedicalHistory,
InsuranceNumber = patientDTO.Lbo
});
patientServiceClient.Execute(patientServiceRequest);
string encryptedJmbg = _encryptionService.EncryptString(patientDTO.Jmbg);
string host = _httpContextAccessor.HttpContext.Request.Host.Value;
var notificationServiceClient = new RestClient(_serviceSettings.NotificationServiceUrl);
var notificationServiceRequest = new RestRequest("/api/notify/activation", Method.POST);
notificationServiceRequest.AddJsonBody(new
{
Email = patientDTO.Email,
Name = patientDTO.Name,
ActivationLink = $"http://{host}/html/activate_account.html?id={encryptedJmbg}"
});
notificationServiceClient.Execute(notificationServiceRequest);
return(NoContent());
}
public async Task <ActionResult <Patient> > CreatePatient(PatientDTO patientDTO)
{
var patient = new Patient
{
FirstName = patientDTO.FirstName,
LastName = patientDTO.LastName,
BirthDate = patientDTO.BirthDate,
Street = patientDTO.Street,
City = patientDTO.City,
Province = patientDTO.Province,
Country = patientDTO.Country,
Postal_Code = patientDTO.Postal_Code,
HasCovid = patientDTO.HasCovid,
Phone = patientDTO.Phone,
Email = patientDTO.Email,
Health_Notes = patientDTO.Health_Notes,
Call_Date = patientDTO.Call_Date,
AgentId = patientDTO.AgentId
};
_context.Patient.Add(patient);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetPatient), new { id = patient.Id }, PatientToDTO(patient)));
}
public async Task <IActionResult> PutPatient(int id, PatientDTO patient)
{
if (id != patient.Id)
{
return(BadRequest());
}
var dbPat = await _context.Patients.FirstOrDefaultAsync(p => p.Id == id);
dbPat.firstName = patient.GivenName;
dbPat.familyName = patient.FamilyName;
dbPat.DOB = patient.DOB;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PatientExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create(PatientDTO vm)
{
if (ModelState.IsValid)
{
ModelState.Clear();
if (vm.FoodPreferences != null)
{
vm.FoodPreferences.Where(x => x.Id == null)
.All(x =>
{
x.Id = Guid.NewGuid().ToString();
return(true);
});
}
try
{
vm.Owner = User.Identity.Name;
vm.Id = Guid.NewGuid().ToString();
repo.Add(false, vm);
await repo.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
ViewData["error"] = "an error occurred";
}
}
return(View("Edit", vm));
}
public async Task <ResponseModel> UpdatePatient(PatientDTO patientDTO)
{
ResponseModel response;
try
{
var patient = mapper.Map <Patient>(patientDTO);
await patientService.UpdatePatient(patient);
response = new ResponseModel
{
HttpResponse = (int)HttpStatusCode.OK,
Response = "El paciente fue actualizado con exito"
};
}
catch (Exception ex)
{
response = new ResponseModel
{
HttpResponse = (int)HttpStatusCode.InternalServerError,
ErrorResponse = ex.Message
};
}
return(response);
}
public List <PatientDTO> GetPatients()
{
List <PatientDTO> patients = new List <PatientDTO>();
String query = "SELECT * FROM Patient";
MySqlCommand cmd = new MySqlCommand(query, dbConn);
dbConn.Open();
MySqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
int id = (int)reader["patient_id"];
String n = reader["name"].ToString();
String yob = reader["birthday"].ToString();
String gender = reader["gender"].ToString();
String Addr = reader["address"].ToString();
String phone = reader["phone"].ToString();
PatientDTO p = new PatientDTO(id, n, yob, gender, Addr, phone);
patients.Add(p);
}
reader.Close();
dbConn.Close();
return(patients);
}
public int Update(PatientDTO patientDTOChanges, int id)
{
if (!PatientExists(id))
{
return(0);
}
using (_connection = new SqlConnection(_connectionString))
{
try
{
var query = $"update Patient set Name=@name,Surname=@surname,Birthdate=@birthdate,Gender=@gender,Email=@email,Health_card_id=@health_card_id,Secret=@secret where id = {id}";
SqlCommand sqlCommand = new SqlCommand(query, _connection);
sqlCommand.Parameters.AddWithValue("@name", patientDTOChanges.Name);
sqlCommand.Parameters.AddWithValue("@surname", patientDTOChanges.Surname);
sqlCommand.Parameters.AddWithValue("@birthdate", patientDTOChanges.Birthdate);
sqlCommand.Parameters.AddWithValue("@gender", patientDTOChanges.Gender);
sqlCommand.Parameters.AddWithValue("@email", patientDTOChanges.Email);
sqlCommand.Parameters.AddWithValue("@health_card_id", patientDTOChanges.HealthCard_id);
sqlCommand.Parameters.AddWithValue("@secret", "-");
_connection.Open();
sqlCommand.ExecuteNonQuery();
return(1);
}
catch
{
throw;
}
}
}
public Task <PatientDTO> AddAsync(PatientDTO patientDTO)
{
using (_connection = new SqlConnection(_connectionString))
{
try
{
var query = "insert into Patient (Name,Surname,Birthdate,Gender,Email,Health_card_id,Secret) values (@name,@surname,@birthdate,@gender,@email,@health_card_id,@secret);SELECT CAST(scope_identity() AS int)";
SqlCommand sqlCommand = new SqlCommand(query, _connection);
sqlCommand.Parameters.AddWithValue("@name", patientDTO.Name);
sqlCommand.Parameters.AddWithValue("@surname", patientDTO.Surname);
sqlCommand.Parameters.AddWithValue("@birthdate", patientDTO.Birthdate);
sqlCommand.Parameters.AddWithValue("@gender", patientDTO.Gender);
sqlCommand.Parameters.AddWithValue("@email", patientDTO.Email);
sqlCommand.Parameters.AddWithValue("@health_card_id", patientDTO.HealthCard_id);
sqlCommand.Parameters.AddWithValue("@secret", "-");
_connection.Open();
var newID = (int)sqlCommand.ExecuteScalar();
var patient = new Patients
{
ID = newID,
Name = patientDTO.Name,
Surname = patientDTO.Surname,
Birthdate = patientDTO.Birthdate,
Gender = patientDTO.Gender,
Email = patientDTO.Email,
HealthCard_id = patientDTO.HealthCard_id
};
return(Task.FromResult(PatientToDTO(patient)));
}
catch
{
throw;
}
}
}
public async Task TestPatientExistsArgumentPropertyNull(string firstName, string lastName)
{
// Arrange
var patient = new PatientDTO
{
FirstName = firstName,
LastName = lastName
};
var cache = new MemoryCache(new MemoryCacheOptions());
var mockLogger = new Mock <ILogger <ExternalPatientApiService> >();
mockLogger.Setup(l => l.Log(
LogLevel.Information,
It.IsAny <EventId>(),
It.IsAny <It.IsAnyType>(),
It.IsAny <Exception>(),
(Func <It.IsAnyType, Exception, string>)It.IsAny <object>()))
.Verifiable();
var service = new ExternalPatientApiService(cache, Mock.Of <IHttpClientFactory>(), Mock.Of <IOptions <ExternalPatientApiOptions> >(), mockLogger.Object);
// Act
async Task TestAction() => await service.PatientExists(null);
// Assert
var ex = await Assert.ThrowsAsync <ArgumentNullException>(TestAction);
}
public PatientDTO Add(PatientDTO patientDTO)
{
using (_connection = new SqlConnection(_connectionString))
{
try
{
var query = "insert into Patient (Name,Surname,Birthdate,Gender,Email,Health_card_id,Secret) values (@name,@surname,@birthdate,@gender,@email,@health_card_id,@secret)";
SqlCommand sqlCommand = new SqlCommand(query, _connection);
sqlCommand.Parameters.AddWithValue("@name", patientDTO.Name);
sqlCommand.Parameters.AddWithValue("@surname", patientDTO.Surname);
sqlCommand.Parameters.AddWithValue("@birthdate", patientDTO.Birthdate);
sqlCommand.Parameters.AddWithValue("@gender", patientDTO.Gender);
sqlCommand.Parameters.AddWithValue("@email", patientDTO.Email);
sqlCommand.Parameters.AddWithValue("@health_card_id", patientDTO.HealthCard_id);
sqlCommand.Parameters.AddWithValue("@secret", "-");
_connection.Open();
sqlCommand.ExecuteNonQuery();
var patient = new Patients
{
Name = patientDTO.Name,
Surname = patientDTO.Surname,
Birthdate = patientDTO.Birthdate,
Gender = patientDTO.Gender,
Email = patientDTO.Email,
HealthCard_id = patientDTO.HealthCard_id
};
return(PatientToDTO(patient));
}
catch
{
throw;
}
}
}
public IHttpActionResult GetPatients(int filter)
{
var dt = bl.GetPatients(filter);
PatientModel patModel = new PatientModel();
foreach (DataRow row in dt.Rows)
{
PatientDTO pat = new PatientDTO
{
id = int.Parse(row["id"].ToString()),
personsid = int.Parse(row["persons_id"].ToString()),
motive = row["motive"].ToString(),
active = Convert.ToBoolean(row["active"]),
idPerson = int.Parse(row["idPerson"].ToString()),
names = row["names"].ToString(),
lastnames = row["lastnames"].ToString(),
address = row["address"].ToString(),
phone = row["phone"].ToString(),
email = row["email"].ToString(),
documentnumber = row["documentnumber"].ToString(),
ruc = row["ruc"].ToString(),
type = row["type"].ToString(),
bussinessname = row["bussinessname"].ToString()
};
patModel.patients.Add(pat);
}
if (dt == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
return(Json(patModel));
}
public async Task <PatientDTO> EditPatientInfo(PatientDTO patient)
{
Patient clientPatient = patient.ConvertToModel();
Patient dbPatient = _patients.Find(p => p.PatientId == clientPatient.PatientId).First();
var updates = new List <UpdateDefinition <Patient> > {
Builders <Patient> .Update.CurrentDate("LastModified")
};
string[] unchanged = { "Id", "PatientId", "LastModified", "Diagnosis" };
IEnumerable <PropertyInfo> properties = typeof(Patient).GetProperties().Where(p => !unchanged.Contains(p.Name));
foreach (PropertyInfo propertyInfo in properties)
{
if (propertyInfo.CanRead)
{
object firstValue = propertyInfo.GetValue(clientPatient);
object secondValue = propertyInfo.GetValue(dbPatient);
if (!Equals(firstValue, secondValue))
{
updates.Add(Builders <Patient> .Update.Set(propertyInfo.Name, firstValue));
}
}
}
var resPatient = await _patients.FindOneAndUpdateAsync(p => p.PatientId == clientPatient.PatientId, Builders <Patient> .Update.Combine(updates));
return(resPatient.ConvertToDTO());
}
public void AddPatient(PatientDTO patientDTO)
{
Database.Patients.Create(new Patient {
Name = patientDTO.Name, Surname = patientDTO.Surname, Patronymic = patientDTO.Patronymic, YearOfBirth = patientDTO.YearOfBirth, Address = patientDTO.Address, Login = patientDTO.Login
});
Database.Save();
}
//event
private void listView_SelectedIndexChanged(object sender, EventArgs e)
{
if (listView.SelectedItems.Count > 0)
{
ListViewItem item = listView.SelectedItems[0];
currentPatient = (PatientDTO)item.Tag;
int id = id_checked = currentPatient.patient_id;
String n = currentPatient.name;
String dob = currentPatient.birthday;
String gender = currentPatient.gender;
String address = currentPatient.addres;
String Phone = currentPatient.phone;
txtName.Text = n;
if (gender == "Nam")
{
genderTx.SelectedIndex = 0;
}
else
{
genderTx.SelectedIndex = 1;
}
if (!string.IsNullOrEmpty(dob))
{
dobTxt.DateTime = DateTime.Parse(dob);
}
string[] Addess_token = address.Split(',');
provinceTxt.Text = Addess_token[0];
districtTxt.Text = Addess_token[1];
townTxt.Text = Addess_token[2];
phoneTxt.Text = Phone;
flag = 1;
}
}
public async Task <ResponseModel> CreatePatient(PatientDTO patientDTO)
{
ResponseModel response;
try
{
var patient = mapper.Map <Patient>(patientDTO);
var patientCreated = await patientService.CreatePatient(patient);
var patientView = mapper.Map <PatientDTO>(patientCreated);
response = new ResponseModel
{
HttpResponse = (int)HttpStatusCode.Created,
Response = patientView
};
}
catch (Exception ex)
{
response = new ResponseModel
{
HttpResponse = (int)HttpStatusCode.InternalServerError,
ErrorResponse = ex.Message
};
}
return(response);
}
public async Task <IActionResult> Edit(PatientDTO patient)
{
try{
var _patient = await _patientRepository.GetPatient(patient.Id);
if (_patient == null)
{
return(NotFound());
}
await _patientService.Atualizar(_mapper.Map <Patient>(patient));
if (await _patientRepository.SaveChangesAsync())
{
return(CreatedAtAction("Index", patient));
}
else
{
return(BadRequest(_notificador));
}
}
catch (Exception ex)
{
return(this.StatusCode(500, "Banco de Dados Falhou"));
}
}
public bool SaveMeasurement(EmployeeDTO employee, OperationDTO operation, PatientDTO patient, DAQSettingsDTO DAQ, BPDataSequenceDTO dataSequence, TransdusorDTO transdusor, string pathcomment, string pathoperation)
{
long OperationID_;
bool saved = true;
int BPdataID_;
string insertStringParamOperation = @"INSERT INTO Operation(OPNurseFirstName, OPNurseLastName, OPNurseIDNumber, NumberOFAlarms, Comments, DurationOperation_hour, DurationOperation_min, DurationOperation_sec, PatientCPR, Complikations)
OUTPUT INSERTED.OperationID
VALUES(@OPNurseFirstName, @OPNurseLastName, @OPNurseIDNumber, @NumberOFAlarms, @Comments, @DurationOperation_hour, @DurationOperation_min, @DurationOperation_sec, @PatientCPR, @Complikations)";
using (SqlCommand cmd = new SqlCommand(insertStringParamOperation, OpenConnection))
{
parameterBuilder_.AddEmployee(cmd, employee);
parameterBuilder_.AddOperation(cmd, operation);
parameterBuilder_.AddComments(cmd, pathcomment);
parameterBuilder_.AddPatient(cmd, patient);
OperationID_ = (long)cmd.ExecuteScalar();
}
string insertStringParamBPDataSequence = @"INSERT INTO BPDataSequence( Raw_Data, Samplerate_hz, Interval_sec, NumberOfSequences, SequenceDuration_sec, Data_Format, Bin_or_Text, Measurement_Format_Type, ConversionConstant_mmhgprmV, ZeroPoint_mmHg, Transdusor_Identification, OperationID )
OUTPUT INSERTED.BPdataID
VALUES(@Raw_Data,@Samplerate_hz, @Interval_sec, @NumberOfSequences, @SequenceDuration_sec, @Data_Format, @Bin_or_Text, @Measurement_Format_Type,@ConversionConstant_mmhgprmV,@ZeroPoint_mmHg,@Transdusor_Identification,@OperationID)";
using (SqlCommand cmd = new SqlCommand(insertStringParamBPDataSequence, OpenConnection))
{
parameterBuilder_.AddRawData(cmd, Zipfolder(pathoperation));
parameterBuilder_.AddDAQ(cmd, DAQ);
parameterBuilder_.AddDataSequence(cmd, dataSequence);
parameterBuilder_.AddTransdusor(cmd, transdusor);
cmd.Parameters.AddWithValue("@OperationID", OperationID_);
BPdataID_ = (int)cmd.ExecuteScalar();
}
return(saved);
}
public async Task <IActionResult> Edit([Bind] PatientResponseViewModel patientResponseViewModel)
{
PatientDTO patient = patientResponseViewModel.PatientResponse;
string url = $"{PatientsApiUrl}Update";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, patient);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Patient has been successfully updated", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to update patient", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
patientResponseViewModel.PatientStatuses = await GetPatientStatuses();
patientResponseViewModel.IdentificationTypes = await GetIdentificationTypes();
patientResponseViewModel.TransmissionClassifications = await GetClassifications();
return(View(patientResponseViewModel));
}
public PatientMessage(string eventType, PatientDTO patientDTO)
{
ID = patientDTO.ID;
Name = patientDTO.Name;
Surname = patientDTO.Surname;
EventType = eventType;
}
public async Task <PatientDTO> CreatePatient(PatientDTO patientDTO)
{
var patient = _mapper.Map <Patient>(patientDTO);
var result = _unitOfWork.PatientRepository.Insert(patient);
await _unitOfWork.SaveAsync();
return(_mapper.Map <PatientDTO>(result));
}
public RegisterPatient()
{
InitializeComponent();
app = Application.Current as App;
RegisteringPatient = new PatientDTO();
this.DataContext = this;
}
public async Task <IHttpActionResult> AddPatient([FromBody] PatientDTO patient)
{
try
{
return(await _manager.AddPateint(patient) ? Created <PatientDiagnosisDTO>("", null) : (IHttpActionResult)BadRequest("changes not excepted!"));
}
catch (Exception ex) { return(InternalServerError(ex)); }
}
public Patient(PatientDTO patientDTO) : base(Guid.NewGuid().ToString(), patientDTO.Name, patientDTO.Surname, patientDTO.Id, patientDTO.DateOfBirth, patientDTO.Contact, patientDTO.Email, patientDTO.Address)
{
this.parentName = patientDTO.ParentName;
this.gender = patientDTO.Gender;
this.Guest = patientDTO.IsGuest;
this.password = patientDTO.Password;
Console.WriteLine(Guest);
}
