public async Task <IActionResult> AddPatient([FromBody] Patient patient)
{
if (ModelState.IsValid)
{
try
{
var Patientid = await patientRepository.AddPatient(patient);
if (Patientid > 0)
{
return(Ok(Patientid));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
else
{
return(BadRequest());
}
}
public void AddPatientRepoTest()
{
PatientModel p = new PatientModel()
{
Hospital = "Inova",
BankName = "bank of america",
Agency = "eo",
Doctor = "ahmed hossien",
IsActive = true,
IsBeneficiary = true,
PatientCID = "333432901010",
BankCode = "001",
CreatedBy = "Jemy",
Iban = "3333222233333333",
EndTreatDate = new DateTime(2019, 1, 1),
Notes = "Some notes 2",
PatientFName = "Mohamed",
PatientLName = "Hasien",
PatientMName = "Ahmed",
KWTPhone = "3456783232",
FirstApptDAte = DateTime.Now,
USPhone = "5712222444",
};
patientRepository.AddPatient(p);
}
public IActionResult AddPatient(PatientForAddDto patient)
{
var newPatientToAdd = _mapper.Map <Patient>(patient);
var newPatient = _repo.AddPatient(newPatientToAdd);
return(Ok(newPatient));
}
public async Task <ActionResult <PatientDto> > AddPatient([FromBody] PatientForCreationDto patientForCreation)
{
var validationResults = new PatientForCreationDtoValidator().Validate(patientForCreation);
validationResults.AddToModelState(ModelState, null);
if (!ModelState.IsValid)
{
return(BadRequest(new ValidationProblemDetails(ModelState)));
//return ValidationProblem();
}
var patient = _mapper.Map <Patient>(patientForCreation);
await _patientRepository.AddPatient(patient);
var saveSuccessful = await _patientRepository.SaveAsync();
if (saveSuccessful)
{
var patientFromRepo = await _patientRepository.GetPatientAsync(patient.PatientId);
var patientDto = _mapper.Map <PatientDto>(patientFromRepo);
var response = new Response <PatientDto>(patientDto);
return(CreatedAtRoute("GetPatient",
new { patientDto.PatientId },
response));
}
return(StatusCode(500));
}
public string Get(string setting)
{
if (setting == "init")
{
var name = _patientRepository.CreateIndex();
_patientRepository.RemoveAllPatients();
for (int i = 0; i < 100; i++)
{
int _age = (new Random().Next(1, 100));
string someJson = @"{""Sameinfo"": """",""nested"": {""nested 2"": 111,""nested"": {""nested 3"": 0,""Verbose"": 20},""ErrorDate"": """"}}";
_patientRepository.AddPatient(new Patient()
{
id = "Pelucid_Client_" + i.ToString(),
name = "Pellucid_" + i.ToString(),
age = _age.ToString(),
sex = i % 2 == 0 ? "M" : "F",
DOB = DateTime.Now.AddYears(-_age),
UpdatedOn = DateTime.Now,
title = "MR",
some_data = (new Random().Next(98929202, 99999999)).ToString(),
primary_phone_no = (new Random().Next(98929202, 99999999)).ToString(),
Addtional_information = MongoDB.Bson.BsonDocument.Parse(someJson)
// Addtional_information = Newtonsoft.Json.Linq.JObject.Parse(someJson)
});;
}
return("Database with 100 patient information created ");
}
return("Unknown");
}
private void AddPatientBtn_Click(object sender, EventArgs e)
{
if (people != null)
{
if (!checkRepository.IsExistPatient(people.CodeMelli, ClinicId))
{
Patient patient = new Patient()
{
PeopleId = people.Id,
ClinicId = this.ClinicId,
};
patientRepository.AddPatient(patient);
var result = MessageBox.Show("عملیات با موفقیت انجام شد", "موفق", MessageBoxButtons.OK);
if (result == DialogResult.OK)
{
this.DialogResult = DialogResult.OK;
this.Close();
}
}
else
{
MessageBox.Show("بیمار قبلا در سامانه ثبت شده است ", "خطا", MessageBoxButtons.OK);
}
}
else
{
MessageBox.Show("لطفا ابتدا یک کدملی معتبر را وارد نموده و بر روی دکمه بررسی کد ملی کلیک نمایید ", "خطا", MessageBoxButtons.OK);
}
}
public IActionResult Create(Patients patients)
{//overloads Create for when the page sends Patient class data over a HttpPost request
if (ModelState.IsValid)
{
var today = DateTime.Today;
var age = today.Year - patients.DOB.Year;
if (patients.DOB.Date > today.AddYears(-age))
{
age--;
}
patients.Age = age; //^uses the patients birth date to calculate their age upon creation^
patients.Location = ""; //sets the patients location data to its defaul value so it gets handled properly by manager view
Patients newPatient = _patientRepository.AddPatient(patients);
var complete = _patientRepository.GetAllPatient().OrderByDescending(e => e.timeMinutes);
_patientList = complete.ToList();
_patientRepository.UpdatePatients(_patientList);//updates the list of patients as well as sorts them in order of longest wait-time to shortest
using (var writer = new StreamWriter("wwwroot/Patients.csv"))
using (var csv = new CsvWriter(writer)) //begins the csv writter to be used and discarded
{
csv.WriteRecords(_patientList); //writes the new list to the csv to save new info
}
return(RedirectToAction("details", new { id = newPatient.ID })); //redirects the user to Details page for the newly created patient
}
return(View());
}
public ActionResult Create(PatientModel patient)
{
ValidatePatientModel(patient);
if (ModelState.IsValid)
{
patient.CreatedBy = User.Identity.Name;
_patientRepository.AddPatient(patient);
Success(string.Format("Patient with Civil ID <b>{0}</b> was successfully added.", patient.PatientCID), true);
if (patient.HasCompanion)
{
return(RedirectToAction("Create", "Companion", new { patientcid = patient.PatientCID }));
}
else
{
return(RedirectToAction("Index"));
}
}
else
{
Danger(string.Format("Please correct the error list before proceeding"), true);
patient.Agencies = _patientManagmentRepository.GetAgencies();
patient.Banks = _patientManagmentRepository.GetBanks();
patient.Hospitals = _patientManagmentRepository.GetHospitals();
patient.Doctors = _patientManagmentRepository.GetDoctors();
patient.Sepcialities = _patientManagmentRepository.GetSpecialities();
return(View(patient));
}
}
/// <summary>
/// Adds patient to patient repository
/// </summary>
/// <param name="patient"></param>
/// <returns>patientID if successfully added, else invalue value '-1'</returns>
public Patient AddPatient(string firstName, string lastName, int age, Gender gender,
string healthCardNumber, string phoneNumber, string address)
{
var patient = new Patient
{
FirstName = firstName,
LastName = lastName,
Age = age,
Gender = gender,
HealthCardNumber = healthCardNumber,
PhoneNumber = phoneNumber,
Address = address
};
_patientRepository.AddPatient(patient);
return(patient);
}
public IActionResult Index(Patient patient)
{
if (ModelState.IsValid)
{
_patientRepository.AddPatient(patient);
return(RedirectToAction("PatientEntered"));
}
return(View(patient));
}
//public void AddPatient([FromBody] Patient patient) => patientRepository.Add(patient);
public ActionResult <PatientDto> PostPatient(PatientDto patientDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid Data"));
}
patientRepository.AddPatient(patientDto);
return(Ok("Added Successfully."));
}
public void Post([FromBody] Patient_Params param)
{
_patientRepository.AddPatient(new Patient
{
id = param.Id,
name = param.name,
UpdatedOn = DateTime.Now
});
}
public ActionResult Create([Bind(Include = "Id,Firstname,Lastname,Pesel,DateOfBirth")] Patient patient)
{
if (ModelState.IsValid)
{
_patientRepository.AddPatient(patient);
_patientRepository.Save();
return(RedirectToAction("Index"));
}
return(View(patient));
}
private void DoGeneratePatients()
{
for (int i = 0; i < 100; i++)
{
var newPatient = patientNameGenerator.NewPatient();
patientRepository.AddPatient(newPatient.Name,
newPatient.Birthday,
newPatient.Alive,
newPatient.ExternalId);
}
MessageBox.Show("100 Patent was generated");
}
public async Task <IActionResult> AddPatient([FromBody] PatientForRegisterDto patientForRegisterDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var patientToCreate = new Patient
{
Pesel = patientForRegisterDto.Pesel,
FileNumber = patientForRegisterDto.FileNumber,
Name = patientForRegisterDto.Name,
SecondName = patientForRegisterDto.SecondName,
Surname = patientForRegisterDto.Surname,
DateOfBirth = patientForRegisterDto.DateOfBirth,
PlaceOfBirth = patientForRegisterDto.PlaceOfBirth,
Gender = patientForRegisterDto.Gender,
GuardianNameAndSurname = patientForRegisterDto.GuardianNameAndSurname,
Foreign = patientForRegisterDto.Foreign,
Country = patientForRegisterDto.Country,
City = patientForRegisterDto.City,
Street = patientForRegisterDto.Street,
HouseNumber = patientForRegisterDto.HouseNumber,
ApartmentNumber = patientForRegisterDto.ApartmentNumber,
ZipCode = patientForRegisterDto.ZipCode,
PostOffice = patientForRegisterDto.PostOffice,
PhoneNumber = patientForRegisterDto.PhoneNumber,
Email = patientForRegisterDto.Email,
Profession = patientForRegisterDto.Profession,
Education = patientForRegisterDto.Education,
Employment = patientForRegisterDto.Employment,
DocumentNumber = patientForRegisterDto.DocumentNumber,
Type = patientForRegisterDto.Type,
Series = patientForRegisterDto.Series,
DocumentCountry = patientForRegisterDto.DocumentCountry,
PersonToAuthName = patientForRegisterDto.PersonToAuthName,
PersonToAuthSurname = patientForRegisterDto.PersonToAuthSurname,
PersonToAuthPesel = patientForRegisterDto.PersonToAuthPesel,
PersonToAuthKinship = patientForRegisterDto.PersonToAuthKinship
};
await _repo.AddPatient(patientToCreate);
return(StatusCode(201));
}
public async Task AddPatient(string email, string password, string pesel,
string firstName, string secondName, string phoneNumber,
string postCode, string city, string street, string houseNumber)
{
var user = await _patientRepository.GetByEmail(email);
user.ifUserExists("This email is existed in db");
user = await _patientRepository.GetByPesel(pesel);
user.ifUserExists("This pesel is existed in db");
var patient = new Patient(new Guid(), email, "patient",
DateTime.UtcNow, firstName, secondName, pesel, phoneNumber,
postCode, city, street, houseNumber);
await _patientRepository.AddPatient(patient);
}
public IActionResult AddPatient([FromBody] PatientRequestDto patientRequest)
{
try
{
if (patientRequest == null)
{
return(BadRequest("Invalid JSON"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid JSON"));
}
var patient = new Patient()
{
Id = Guid.NewGuid(),
First_Name = patientRequest.First_Name,
Last_Name = patientRequest.Last_Name,
Gender = patientRequest.Gender,
Date_Of_Birth = patientRequest.Date_Of_Birth,
Email = patientRequest.Email,
Phone = patientRequest.Phone,
Is_Active = patientRequest.Is_Active,
Created_At = DateTime.UtcNow,
Updated_At = DateTime.UtcNow
};
var isPatientAdded = _patientRepository.AddPatient(patient);
if (isPatientAdded)
{
return(Created("", patient));
}
else
{
return(StatusCode(500, "Unexpected error happened. Please try after sometime"));
}
}
catch (Exception)
{
return(StatusCode(500, "Unexpected error happened. Please try after sometime"));
}
}
public IActionResult Post([FromBody] Models.PatientModel newPatient)
{
try
{
var msg = _patientRepository.AddPatient(newPatient);
if (msg)
{
return(Json("Patient added to the bed"));
}
else
{
return(Json("Patient couldnot be added"));
}
}
catch (Exception)
{
return(StatusCode(500, "unable to insert new Patient"));
}
}
public ActionResult AddPatients(Patients model)
{
if (!ModelState.IsValid)
{
TempData["error"] = "Check your values";
return(View(nameof(AddPatients), model));
}
try
{
_repository.AddPatient(model);
TempData["success"] = $"Patients created success fully. Regno: {model.patients_regno}";
return(RedirectToAction(nameof(patients), new { regno = model.patients_regno }));
}
catch (Exception ex)
{
TempData["error"] = ex.Message;
}
return(View("AddPatients", model));
}
public async Task Register(string email, string password, string firstName,
string secondName, string pesel, string phoneNumber, string postCode,
string city, string street, string houseNumber)
{
var user = await _userRepository.GetByEmail(email);
user.ifUserExists("This email is existed in db");
user = await _userRepository.GetByPesel(pesel);
user.ifUserExists("This pesel is existed in db");
var patientToCreate = new Patient(Guid.NewGuid(), email, "patient", DateTime.UtcNow,
firstName, secondName, pesel, phoneNumber, postCode, city, street, houseNumber);
var hmac = new System.Security.Cryptography.HMACSHA512();
patientToCreate.PasswordSalt = hmac.Key;
patientToCreate.PasswordHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password));
await _patientRepository.AddPatient(patientToCreate);
}
public async Task <Appointment> AddAppointment(NewAppointment appointment)
{
var pat = await this.patientRepository.GetByName(appointment.Full_Name);
if (pat == null)
{
var newPat = new Patient()
{
Full_Name = appointment.Full_Name,
Card = new Card()
};
pat = await patientRepository.AddPatient(newPat);
}
var app = new Appointment()
{
PatientId = pat.Id,
DoctorId = appointment.DoctorId,
End_Appointment = appointment.End_Appointment,
Start_Appointment = appointment.Start_Appointment
};
return(await this.appointmentRepository.AddAppointment(app));
}
public PatientDetail AddPatient(PatientDetail patientDetail)
{
return(_patientRepository.AddPatient(patientDetail));
}
public void AddPatient(PatientDto patient)
{
_patientRepository.AddPatient(_mapper.Map <PatientDto, Patient>(patient));
}
public void Post([FromBody] Patient newPatient)
{
_PatientRepository.AddPatient(new Patient
{
gender = newPatient.gender,
patient_nbr = newPatient.patient_nbr,
diabetes_med = newPatient.diabetes_med,
#region rest
num_medications = newPatient.num_medications,
admission_type_id = newPatient.admission_type_id,
acarbose = newPatient.acarbose,
medical_specialty = newPatient.medical_specialty,
rosiglitazone = newPatient.rosiglitazone,
glipizide = newPatient.glipizide,
chlorpropamide = newPatient.chlorpropamide,
metformin_rosiglitazone = newPatient.metformin_rosiglitazone,
time_in_hospital = newPatient.time_in_hospital,
examide = newPatient.examide,
readmitted = newPatient.readmitted,
encounter_id = newPatient.encounter_id,
max_glu_serum = newPatient.max_glu_serum,
num_lab_procedures = newPatient.num_lab_procedures,
change = newPatient.change,
num_procedures = newPatient.num_procedures,
diag_1 = newPatient.diag_1,
insulin = newPatient.insulin,
tolazamide = newPatient.tolazamide,
a1_cresult = newPatient.a1_cresult,
number_outpatient = newPatient.number_outpatient,
glyburide = newPatient.glyburide,
nateglinide = newPatient.nateglinide,
glimepiride = newPatient.glimepiride,
discharge_disposition_id = newPatient.discharge_disposition_id,
payer_code = newPatient.payer_code,
age = newPatient.age,
number_inpatient = newPatient.number_inpatient,
glimepiride_pioglitazone = newPatient.glimepiride_pioglitazone,
repaglinide = newPatient.repaglinide,
miglitol = newPatient.miglitol,
tolbutamide = newPatient.tolbutamide,
weight = newPatient.weight,
pioglitazone = newPatient.pioglitazone,
citoglipton = newPatient.citoglipton,
acetohexamide = newPatient.acetohexamide,
metformin = newPatient.metformin,
troglitazone = newPatient.troglitazone,
diag_2 = newPatient.diag_2,
number_diagnoses = newPatient.number_diagnoses,
glyburide_metformin = newPatient.glyburide_metformin,
diag_3 = newPatient.diag_3,
glipizide_metformin = newPatient.glipizide_metformin,
metformin_pioglitazone = newPatient.metformin_pioglitazone,
admission_source_id = newPatient.admission_source_id,
race = newPatient.race,
number_emergency = newPatient.number_emergency,
#endregion
//CreatedOn = DateTime.Now,
UpdatedOn = DateTime.Now
});
}
public async Task AddPatient(PatientDTO patient)
{
await _patientRepository.AddPatient(patient);
}
public bool AddPatient(Patient newPatient)
{
return(patientRepository.AddPatient(newPatient));
}
public ActionResult <List <PatientDTO> > PostPatient(PatientDTO PatientDTO)
{
pr.AddPatient(PatientDTO);
return(Ok(PatientDTO.PatientId));
}
public void AddPatient(PatientDTO patient)
{
var patientEntity = patient.ToDTO <DentistApp.DAL.Models.Entities.Patient>();
_patientRepository.AddPatient(patientEntity);
}
public async Task <Patient> AddPatient(Patient patient)
{
return(await patientRepository.AddPatient(patient));
}
public void AddPatient(PatientModel patient)
{
_patientRepository.AddPatient(patient);
}
