public async Task <IActionResult> Login(AuthModel model)
{
try
{
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.Authorize, new Parameter[] {
new Parameter("model", JsonConvert.SerializeObject(model), ParameterType.RequestBody)
}));
var user = new Users();
if (userResponse.Success)
{
user = JsonConvert.DeserializeObject <Users>(userResponse.Data);
await Authenticate(user.UserId.ToString());
ViewBag.Role = (RoleTypes)user.Role;
return(RedirectToAction("Index", "Home"));
}
ViewBag.Role = RoleTypes.None;
ModelState.AddModelError("", "Uncorrect login or password");
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
return(View(model));
}
public async Task <IActionResult> TakePatient()
{
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.GetPatientsWithNoReception));
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
var ids = JsonConvert.DeserializeObject <long[]>(testingResponse.Data);
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatientsByIds, new Parameter[] {
new Parameter("ids", JsonConvert.SerializeObject(ids), ParameterType.RequestBody)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
var outpatients = JsonConvert.DeserializeObject <List <PatientModel> >(userResponse.Data);
ViewBag.Patients = outpatients.Select(x => x.Fio);
return(View());
}
public async Task <IActionResult> Index()
{
var role = await _controllerRepository.InitRole(User);
if (role == RoleTypes.Patient)
{
var userId = _controllerRepository.GetUserId(User);
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.CheckNotViewedAnswer, new Parameter[] {
new Parameter("userId", userId, ParameterType.RequestBody)
}));
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
var result = JsonConvert.DeserializeObject <bool>(testingResponse.Data);
if (result)
{
return(RedirectToAction("AlreadyHasCompleteTest", "Test"));
}
return(View());
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> AlreadyHasCompleteTest()
{
var userId = _controllerRepository.GetUserId(User);
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.GetPreDiseaseId, new Parameter[] {
new Parameter("userId", userId, ParameterType.GetOrPost)
}));
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
var diseaseId = JsonConvert.DeserializeObject <long>(testingResponse.Data);
var medicalResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.GetDiseaseNameById, new Parameter[] {
new Parameter(
"diseaseId", diseaseId, ParameterType.GetOrPost)
}));
if (!medicalResponse.Success)
{
throw new Exception(medicalResponse.Data);
}
ViewBag.PreDiagnos = medicalResponse.Data;
return(View());
}
public async Task <IActionResult> UpdatePatient(PatientModel model)
{
try
{
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.UpdatePatientInfo, new Parameter[] {
new Parameter("model", JsonConvert.SerializeObject(model), ParameterType.RequestBody)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
return(Json(
new
{
Success = true,
Data = "Ok"
}));
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
}
public async Task <long> PassTest(AnswerModel answerModel)
{
var userResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatientByUserId,
new Parameter[] {
new Parameter("userId", answerModel.UserId, ParameterType.GetOrPost)
});
var patientData = JsonConvert.DeserializeObject <MksResponse>(userResponse);
if (!patientData.Success)
{
throw new Exception(patientData.Data);
}
var patientCtx = JsonConvert.DeserializeObject <Patients>(patientData.Data);
var stringArr = answerModel.Answers.Select(x => x.Answer);
var answerData = string.Join(';', stringArr);
var answer = new Answers
{
AnswerData = answerData,
AnswerDate = DateTime.UtcNow,
PatientId = patientCtx.PatientId
};
_context.Answers.Add(answer);
await _context.SaveChangesAsync();
return(answer.AnswerId);
}
public async Task UpdateDescription(CardDescriptionModel model)
{
var outpatientCard = await _context.OutpatientCards.FirstOrDefaultAsync(x => x.OutpatientCardId == model.CardId);
if (outpatientCard == null)
{
throw new Exception($"Outpatient card not found. {model.CardId}");
}
outpatientCard.Description += "\n" + model.Description;
if (!outpatientCard.DiseaseId.HasValue)
{
var diseaseResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.GetDiseaseIdByName,
new Parameter[] {
new Parameter("name", model.Disease, ParameterType.GetOrPost)
});
var diseaseResponseName = JsonConvert.DeserializeObject <MksResponse>(diseaseResponse);
if (!diseaseResponseName.Success)
{
throw new Exception("Disease not found");
}
outpatientCard.DiseaseId = JsonConvert.DeserializeObject <long>(diseaseResponseName.Data);
}
await _context.SaveChangesAsync();
}
public async Task ShowRules()
{
string name = null;
var request = new RestRequest($"act_{_acc}/{_strDict.AdrulesLibrary}", Method.GET);
request.AddQueryParameter(_strDict.Fields, _strDict.EntityType + "," + _strDict.EvaluationSpec + ","
+ _strDict.ExecutionSpec + "," + _strDict.Name + ","
+ _strDict.ScheduleSpec + "," + _strDict.ExecutionType);
var json = await _reqEx.ExecuteRequestAsync(request);
foreach (var rule in json[_strDict.Data])
{
JToken filter = rule[_strDict.EvaluationSpec][_strDict.Filters];
JToken trigger = rule[_strDict.EvaluationSpec][_strDict.Trigger];
var result = Navigator.TranslateRules(trigger, filter);
name = rule[_strDict.Name].ToString();
}
Assert.AreEqual("test", name);
}
public async Task <IActionResult> DoctorRoom(CreatorModel model)
{
if (model.IsDoctor)
{
var doctorId = _controllerRepository.GetUserId(User);
ViewBag.DoctorId = doctorId;
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetUserByPatientId, new Parameter[] {
new Parameter("patientId", model.UserId, ParameterType.GetOrPost)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
var user2 = JsonConvert.DeserializeObject <Users>(userResponse.Data);
ViewBag.PatientUserId = user2.UserId;
ViewBag.Role = "creator";
}
else
{
ViewBag.DoctorId = model.UserId;
var patientUserId = _controllerRepository.GetUserId(User);
ViewBag.PatientUserId = patientUserId;
ViewBag.Role = "user";
}
var userResponse2 = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetUserById, new Parameter[] {
new Parameter("userId", ViewBag.DoctorId, ParameterType.GetOrPost)
}));
if (!userResponse2.Success)
{
throw new Exception(userResponse2.Data);
}
var user = JsonConvert.DeserializeObject <Users>(userResponse2.Data);
var userResponse3 = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatientByUserId, new Parameter[] {
new Parameter("userId", ViewBag.PatientUserId, ParameterType.GetOrPost)
}));
if (!userResponse3.Success)
{
throw new Exception(userResponse3.Data);
}
var patient = JsonConvert.DeserializeObject <PatientModel>(userResponse3.Data);
ViewBag.PatientName = patient.Fio;
ViewBag.DoctorName = user.Fio;
return(View());
}
public async Task <Diseases> DiseaseDiagnostic(long answerId)
{
var diseaseResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.EvaluateAnswer,
new Parameter[] {
new Parameter("id", 1, ParameterType.RequestBody)
});
var diseaseName = JsonConvert.DeserializeObject <MksResponse>(diseaseResponse);
return(null);
}
public async Task <IActionResult> PatientReception(PatientFioModel model)
{
var userResponse = JsonConvert.DeserializeObject <MksResponse>(await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatientByFio,
new Parameter[] {
new Parameter("fio", model.Fio, ParameterType.GetOrPost)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
var patient = JsonConvert.DeserializeObject <PatientModel>(userResponse.Data);
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.GetPreDiseaseId, new Parameter[] {
new Parameter("userId", long.Parse(patient.UserId), ParameterType.GetOrPost)
}));
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
var diseaseId = JsonConvert.DeserializeObject <long>(testingResponse.Data);
var medicalResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.GetDiseaseNameById, new Parameter[] {
new Parameter(
"diseaseId", diseaseId, ParameterType.GetOrPost)
}));
if (!medicalResponse.Success)
{
throw new Exception(medicalResponse.Data);
}
var medicalResponse2 = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.GetAllDiseases));
if (!medicalResponse2.Success)
{
throw new Exception(medicalResponse2.Data);
}
var diseases = JsonConvert.DeserializeObject <List <string> >(medicalResponse2.Data);
ViewBag.PreDiagnos = medicalResponse.Data;
ViewBag.PatientId = patient.PatientId;
ViewBag.Diseases = diseases;
return(View(patient));
}
public async Task <IActionResult> Index()
{
var medicalResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.GetOutpatients));
if (!medicalResponse.Success)
{
throw new Exception(medicalResponse.Data);
}
var outpatients = JsonConvert.DeserializeObject <List <OutpatientModel> >(medicalResponse.Data);
return(View(outpatients));
}
public async Task <IActionResult> Drugs()
{
var medicalResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.GetDrugs));
if (!medicalResponse.Success)
{
throw new Exception(medicalResponse.Data);
}
var drugs = JsonConvert.DeserializeObject <List <Drug> >(medicalResponse.Data);
return(View(drugs));
}
public async Task <IActionResult> UpdateDescription(CardDescriptionModel model)
{
var medicalResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.UpdateDescription, new Parameter[] {
new Parameter("model", JsonConvert.SerializeObject(model), ParameterType.RequestBody)
}));
if (!medicalResponse.Success)
{
throw new Exception(medicalResponse.Data);
}
return(RedirectToAction("Index", "Outpatient"));
}
public async Task <IActionResult> CreateCard()
{
var userId = _controllerRepository.GetUserId(User);
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.CreateOutpatientCard, new Parameter[] {
new Parameter("userId", userId, ParameterType.RequestBody)
}));
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
return(Json(new { Success = true, Message = "ok" }));
}
public async Task <OutpatientModel> GetOutpatientByPatientAndDoctorId(DoctorPatientModel model)
{
var outpatient = await _context.OutpatientCards
.FirstOrDefaultAsync(x => x.PatientId == model.PatientId && x.DoctorId == model.DoctorId);
var newOutpatient = new OutpatientModel
{
CreatedDate = outpatient.CreatedDate.Value.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture),
Description = outpatient.Description,
OutpatientCardId = outpatient.OutpatientCardId,
Status = (OutpatientStatuses)outpatient.Status
};
var userResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatientById,
new Parameter[]
{
new Parameter("patientId", (int)outpatient.PatientId, ParameterType.GetOrPost)
});
var patientData = JsonConvert.DeserializeObject <MksResponse>(userResponse);
if (!patientData.Success)
{
throw new Exception(patientData.Data);
}
var patientCtx = JsonConvert.DeserializeObject <Patients>(patientData.Data);
newOutpatient.Patient = patientCtx;
var diseaseResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.GetDiseaseNameById,
new Parameter[] {
new Parameter("diseaseId", model.DiseaseId, ParameterType.GetOrPost)
});
var diseaseResponseName = JsonConvert.DeserializeObject <MksResponse>(diseaseResponse);
var diseaseName = string.Empty;
if (diseaseResponseName.Success)
{
diseaseName = JsonConvert.DeserializeObject <string>(diseaseResponseName.Data);
}
outpatient.DiseaseId = model.DiseaseId;
await _context.SaveChangesAsync();
newOutpatient.Disease = diseaseName;
return(newOutpatient);
}
public async Task <IActionResult> GetTest()
{
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.GetQuestions));
var questions = new List <Questions>();
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
else
{
questions.AddRange(JsonConvert.DeserializeObject <IEnumerable <Questions> >(testingResponse.Data));
}
return(View(questions));
}
public async Task <bool> CheckNotViewedAnswer(long userId)
{
var userResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatientByUserId,
new Parameter[] {
new Parameter("userId", userId, ParameterType.GetOrPost)
});
var patientData = JsonConvert.DeserializeObject <MksResponse>(userResponse);
if (!patientData.Success)
{
throw new Exception(patientData.Data);
}
var patientCtx = JsonConvert.DeserializeObject <Patients>(patientData.Data);
return(await _context.Answers.AnyAsync(x => x.PatientId.HasValue &&
x.PatientId.Value == patientCtx.PatientId && !x.IsTakenToCalculate.HasValue));
}
public async Task CreateOutpatientCard(long userId)
{
var userResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetUsers);
var userData = JsonConvert.DeserializeObject <MksResponse>(userResponse);
if (!userData.Success)
{
throw new Exception(userData.Data);
}
var users = JsonConvert.DeserializeObject <List <Users> >(userData.Data);
var freeDoctor = users.FirstOrDefault(x => x.Role == (byte)RoleTypes.Doctor);
if (freeDoctor == null)
{
throw new Exception("Free doctors not found");
}
var userResponse2 = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatientByUserId, new Parameter[]
{
new Parameter("userId", (int)userId, ParameterType.GetOrPost)
});
var userData2 = JsonConvert.DeserializeObject <MksResponse>(userResponse2);
if (!userData2.Success)
{
throw new Exception(userData2.Data);
}
var patient = JsonConvert.DeserializeObject <Patients>(userData2.Data);
var newOutpatientCard = new OutpatientCards
{
CreatedDate = DateTime.UtcNow,
Description = "Card created successfully",
DoctorId = freeDoctor.UserId,
PatientId = patient.PatientId,
Status = (byte)OutpatientStatuses.OutpatientCardCreating
};
_context.OutpatientCards.Add(newOutpatientCard);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> DeleteUser(string userId)
{
try
{
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.RemoveUser, new Parameter[] {
new Parameter("userId", long.Parse(userId), ParameterType.RequestBody)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
return(Json(new { Success = true, Message = "ok" }));
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
}
/// <summary>
/// Добавление правил в таблицу DataGrid.
/// </summary>
/// <param name="acc">id рк.</param>
public async void ShowRules(string acc)
{
DataGridView.Rows.Clear();
var request = new RestRequest($"act_{acc}/{_strDict.AdrulesLibrary}", Method.GET);
request.AddQueryParameter(_strDict.Fields, _strDict.EntityType + "," + _strDict.EvaluationSpec + ","
+ _strDict.ExecutionSpec + "," + _strDict.Name + ","
+ _strDict.ScheduleSpec + "," + _strDict.ExecutionType);
var json = await _reqEx.ExecuteRequestAsync(request);
foreach (var rule in json[_strDict.Data])
{
JToken filter = rule[_strDict.EvaluationSpec][_strDict.Filters];
JToken trigger = rule[_strDict.EvaluationSpec][_strDict.Trigger];
var result = Navigator.TranslateRules(trigger, filter);
DataGridView.Rows.Add(rule[_strDict.Name], result.Item1, result.Item2, result.Item3, result.Item4);
}
}
public async Task <IActionResult> GetDoctorIdByFio(string fio)
{
try
{
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetDoctorIdByFio, new Parameter[] {
new Parameter("fio", fio, ParameterType.GetOrPost)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
var userid = JsonConvert.DeserializeObject <long>(userResponse.Data);
return(Json(new { Success = true, Data = userid }));
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
}
public async Task <RoleTypes> InitRole(ClaimsPrincipal claimsPrincipal)
{
var identity = (ClaimsIdentity)claimsPrincipal.Identity;
if (identity.Claims.Any())
{
var userId = identity.Claims.ToList()[0].Value;
var userResponse = JsonConvert.DeserializeObject <MksResponse>(await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetUserById,
new Parameter[] {
new Parameter("userId", long.Parse(userId), ParameterType.GetOrPost)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
var user = JsonConvert.DeserializeObject <Users>(userResponse.Data);
return((RoleTypes)user.Role);
}
return(RoleTypes.None);
}
public async Task <IActionResult> TryAgain()
{
try
{
var userId = _controllerRepository.GetUserId(User);
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.RemoveAnswer, new Parameter[] {
new Parameter("userId", userId, ParameterType.RequestBody)
}));
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
return(Json(new { Result = true }));
}
catch (Exception exception)
{
ModelState.AddModelError(nameof(exception), exception.ToString());
throw;
}
}
public async Task <IActionResult> PatientRoom()
{
var role = await _controllerRepository.InitRole(User);
if (role == RoleTypes.None)
{
return(RedirectToAction("Login", "User"));
}
if (role != RoleTypes.Patient)
{
return(RedirectToAction("Index", "Home"));
}
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetDoctors));
var user = new List <string>();
if (userResponse.Success)
{
user.AddRange(JsonConvert.DeserializeObject <IEnumerable <string> >(userResponse.Data));
}
ViewBag.Doctors = user;
return(View());
}
public async Task <IEnumerable <PatientModel> > GetPatientsNoReception()
{
var testingResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.GetPatientsWithNoReception);
var answersData = JsonConvert.DeserializeObject <MksResponse>(testingResponse);
if (!answersData.Success)
{
throw new Exception(answersData.Data);
}
var patientsIds = JsonConvert.DeserializeObject <long[]>(answersData.Data);
var result = new List <PatientModel>();
if (patientsIds.Any())
{
foreach (var id in patientsIds)
{
result.AddRange(await(from p in _context.Patients
join u in _context.Users on p.UserId equals u.UserId
where p.PatientId == id
select new PatientModel
{
PatientId = p.PatientId.ToString(),
UserId = u.UserId.ToString(),
DateBirth = p.DateBirth.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture),
Fio = p.Fio,
Gender = p.Gender ? "male" : "female",
Password = u.Password,
PhoneNumber = u.PhoneNumber,
WorkPlace = p.WorkPlace
}).ToListAsync());
}
}
return(result);
}
public async Task <IActionResult> PassTheTest([FromBody] AnswerItem[] answers)
{
try
{
var userId = _controllerRepository.GetUserId(User);
var testingResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.PassTheTest, new Parameter[] {
new Parameter("model", JsonConvert.SerializeObject(new AnswerModel
{
UserId = userId,
Answers = answers
}), ParameterType.RequestBody)
}));
if (!testingResponse.Success)
{
throw new Exception(testingResponse.Data);
}
var answerId = long.Parse(testingResponse.Data);
var testingResponse2 = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Testing, RequestUrl.EvaluateAnswer, new Parameter[] {
new Parameter("id", answerId, ParameterType.RequestBody)
}));
if (!testingResponse2.Success)
{
throw new Exception(testingResponse2.Data);
}
return(Json(new { Result = true }));
}
catch (Exception exception)
{
ModelState.AddModelError(nameof(exception), exception.ToString());
throw;
}
}
public async Task <IEnumerable <PatientModel> > GetPatientsByIds(long[] ids)
{
var result = new List <PatientModel>();
var medicalResponse = await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.Medical, RequestUrl.ActualizeIds,
new Parameter[] {
new Parameter("ids", JsonConvert.SerializeObject(ids), ParameterType.RequestBody)
});
var medicalData = JsonConvert.DeserializeObject <MksResponse>(medicalResponse);
if (!medicalData.Success)
{
throw new Exception(medicalData.Data);
}
ids = JsonConvert.DeserializeObject <long[]>(medicalData.Data);
foreach (var id in ids)
{
var patient = await _context.Patients.FirstOrDefaultAsync(x => x.PatientId == id);
var user = await _context.Users.FirstOrDefaultAsync(x => x.UserId == patient.UserId);
result.Add(new PatientModel
{
PatientId = patient.PatientId.ToString(),
UserId = user.UserId.ToString(),
DateBirth = patient.DateBirth.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture),
Fio = patient.Fio,
Gender = patient.Gender ? "male" : "female",
Password = user.Password,
PhoneNumber = user.PhoneNumber,
WorkPlace = patient.WorkPlace
});
}
return(result);
}
public async Task <IActionResult> Patients()
{
var role = await _controllerRepository.InitRole(User);
ViewBag.Role = role;
//if (role == RoleTypes.None)
// return RedirectToAction("Login", "User");
//if (role == RoleTypes.Patient)
// return RedirectToAction("Index", "Home");
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.GetPatients));
var users = new List <PatientModel>();
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
else
{
users.AddRange(JsonConvert.DeserializeObject <IEnumerable <PatientModel> >(userResponse.Data));
}
return(View(users));
}
public async Task <IActionResult> Registration(PatientModel model)
{
try
{
var userResponse = JsonConvert.DeserializeObject <MksResponse>(
await RequestExecutor.ExecuteRequestAsync(
MicroservicesEnum.User, RequestUrl.Registration, new Parameter[] {
new Parameter("model", model, ParameterType.RequestBody)
}));
if (!userResponse.Success)
{
throw new Exception(userResponse.Data);
}
await Authenticate(model.UserId);
ViewBag.Role = await _controllerRepository.InitRole(User);
return(RedirectToAction("Index", "Home"));
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
}
