public async Task <FirebaseAuthLink> LoginAsync(string email, string password)
{
var checkUser = await _firebaseAuthProvider.SignInWithEmailAndPasswordAsync(email, password);
var isDoctor = new GetDoctor(_client).Do(checkUser.User.LocalId).Result.Email;
if (!string.IsNullOrEmpty(isDoctor))
{
return(checkUser);
}
throw new FirebaseAuthException("login", email + " " + password, "402", new Exception(), AuthErrorReason.InvalidIdentifier);
//var a = await _firebaseAuthProvider.GetUserAsync(auth.FirebaseToken);
/* _firebaseAuthProvider.Ref
* return new UserBasicInfo
* {
* Id = auth.User.LocalId,
* Email = auth.User.Email,
* AccessToken = auth.FirebaseToken,
* RefreshToken = auth.RefreshToken
* };*/
}
public void GetDoctor()
{
GetDoctor doctor = new GetDoctor(client);
var dr = doctor.Do("MWBywMkevROEsmY4ubha7yXBZms1").Result;
Assert.AreEqual("*****@*****.**", dr.Email);
}
public async Task <IEnumerable <PatientViewModel> > Do(string doctorId)
{
//_storage.Options.
GetDoctor dr = new GetDoctor(_client);
List <PatientViewModel> patientsRes = new List <PatientViewModel>();
var patients = await _client
.Child("Patient")
//.OrderByKey()
.OnceAsync <Domain.Models.Patient>();
if (!string.IsNullOrEmpty(doctorId))
{//Doktora ait hastalar
foreach (var patient in patients)
{
foreach (var item2 in patient.Object.MeasurementResults)
{
if (item2.Diognasis.DoctorID == doctorId)
{
var measurementResult = patient.Object.MeasurementResults.LastOrDefault();
patientsRes.Add(new PatientViewModel
{
UID = patient.Key,
PatientDetails = patient.Object.PatientDetails,
Diognasis = measurementResult.Diognasis.Status,
DiognasisDate = measurementResult.Date,
DiognasisTime = measurementResult.Time //,
//Doctor = String.IsNullOrEmpty(measurementResult.Diognasis.DoctorID) != false ? dr.Do(measurementResult.Diognasis.DoctorID).Result.Email : ""
});
break;
}
}
}
return(patientsRes.AsEnumerable());
}
//Tüm hastalar
foreach (var patient in patients)
{
var measurementResult = patient.Object.MeasurementResults.LastOrDefault();
patientsRes.Add(new PatientViewModel
{
UID = patient.Key,
PatientDetails = patient.Object.PatientDetails,
Diognasis = measurementResult.Diognasis.Status,
DiognasisDate = measurementResult.Date,
DiognasisTime = measurementResult.Time,
Doctor = !String.IsNullOrEmpty(measurementResult.Diognasis.DoctorID) ? dr.Do(measurementResult.Diognasis.DoctorID).Result.Email : ""
});
}
return(patientsRes.AsEnumerable());
}
public IActionResult GetDoctor()
{
Doctor doctor;
var doctorId = HttpContext.GetCurrentUser().Id;
/* if (!_cache.TryGetValue(doctorId, out doctor))
* {
* var cacheExpOptions = new MemoryCacheEntryOptions
* {
* AbsoluteExpiration = DateTime.Now.AddMinutes(30)
* };
*/
doctor = new GetDoctor(_client).Do(doctorId).Result;
/* _cache.Set(doctorId, doctor, cacheExpOptions);
* }*/
return(Ok(doctor));
}
public async Task <Response> Do(Request request)
{
GetDoctor dr = new GetDoctor(_client);
request.Comment.Date = DateTime.Today.ToString("d");
request.Comment.Time = DateTime.Now.ToShortTimeString();
await _client
.Child("Patient")
.Child(request.PatientID)
.Child("MeasurementResults")
.Child(request.MeasurementResultID)
.Child("Diognasis").Child("Comments").Child(string.IsNullOrEmpty(request.commentId) ? "0" : request.commentId).PutAsync(request.Comment);
request.Comment.DrID = dr.Do(request.Comment.DrID).Result.Email;
return(new Response
{
Comment = request.Comment
});
}
public void UpdateDoctor()
{
GetDoctor doctor = new GetDoctor(client);
UpdateDoctor updateDoctor = new UpdateDoctor(client);
var dr = doctor.Do("MWBywMkevROEsmY4ubha7yXBZms1").Result;
updateDoctor.Do("MWBywMkevROEsmY4ubha7yXBZms1", new Domain.Models.Doctor
{
FirstName = "Fatih1",
LastName = "Yýldýz1",
Email = "*****@*****.**",
Phone = 55606582,
Degree = "DRdegreeTest"
}).Result.ToString();
var drUpdated = doctor.Do("MWBywMkevROEsmY4ubha7yXBZms1").Result;
Assert.AreEqual(dr.Email, drUpdated.Email);
Assert.AreNotEqual(dr.Degree, drUpdated.Degree);
Assert.AreEqual(dr.FirstName, drUpdated.FirstName);
Assert.AreEqual(dr.LastName, drUpdated.LastName);
Assert.AreEqual(dr.Phone, drUpdated.Phone);
}
public async Task <PatientViewModel> Do(string uid, string olcOrder, string drId)
{
var patients = await _client
.Child("Patient")
.OnceAsync <Domain.Models.Patient>();
var patient = patients.FirstOrDefault(x => x.Key == uid).Object;
List <Diagnosis> diagnoses = new List <Diagnosis>();
GetDoctor dr = new GetDoctor(_client);
if (!String.IsNullOrEmpty(olcOrder))
{
var measurement = patient.MeasurementResults[int.Parse(olcOrder)];
patient.MeasurementResults = new List <MeasurementResults>();
patient.MeasurementResults.Add(measurement);
}
int i = 0;
foreach (var item in patient.MeasurementResults)
{
bool emergancy = false;
bool.TryParse(item.Diognasis.Emergancy, out emergancy);
diagnoses.Add(new Diagnosis
{
DiognasisDate = item.Date,
DiognasisTime = item.Time,
MeasurementId = item.OlcID,
Status = item.Diognasis.Status,
Doctor = dr.Do(item.Diognasis.DoctorID).Result.Email,
olcOrder = String.IsNullOrEmpty(olcOrder) ? i.ToString() : olcOrder,
Emergancy = emergancy,
Comments = !string.IsNullOrEmpty(olcOrder) ? item.Diognasis.Comments : new List <Comments>(),
IsMe = item.Diognasis.DoctorID == drId ? "true" : "false",
Content = item.Diognasis.Content
});
i++;
}
foreach (var diagnosis in diagnoses)
{
if (diagnosis.Comments != null)
{
foreach (var item in diagnosis.Comments)
{
item.DrID = dr.Do(item.DrID).Result.Email;
}
}
}
return(new PatientViewModel
{
BirthDay = patient.PatientDetails.BirthDay,
Name = patient.PatientDetails.FirstName,
LastName = patient.PatientDetails.LastName,
UID = uid,
Weight = patient.PatientDetails.Weight,
Diagnoses = diagnoses,
Gender = patient.PatientDetails.Gender,
CurrentDoctor = drId
});
}
