private void AuthorizationBtn_Click(object sender, RoutedEventArgs e)
{
if (!string.IsNullOrWhiteSpace(loginTxtBx.Text) && !string.IsNullOrWhiteSpace(passwordTxtBx.Text))
{
DataBase.User currentUser = new DataBase.User();
currentUser.Login = loginTxtBx.Text;
currentUser.Password = passwordTxtBx.Text;
DataBase.User user = Logic.DBQuery.Authorization(currentUser);
if (user != null)
{
if (user.Login != null)
{
GameWindow gameWindow = new GameWindow(user);
Close();
gameWindow.Show();
}
else
{
MessageBox.Show("Данной записи не существует. Пожалуйста, проверьте правильность ввода данных", "Отсутствие данных");
}
}
else
{
MessageBox.Show("Что-то пошло не так. Пожалуйста зайдите позже...", "Ошибка подключения");
}
}
else
{
MessageBox.Show("Сначала заполните все поля!", "Ошибка заполнения");
}
}
public void Login(string sceneName)
{
if (emailLogin.text == "" || passLogin.text == "")
{
error.text = "No debe haber campos vacíos";
Debug.LogError("No debe haber campos vacíos");
}
else
{
DataBase.User user = DataBase.GetUser(emailLogin.text, passLogin.text);
if (user.Email != null)
{
Debug.Log("Bienvenido/a " + user.Name + ", tu útlimo puntaje fue: " + user.Score);
PlayerPrefs.SetString("Name", user.Name);
PlayerPrefs.SetString("Email", emailLogin.text);
UIController.ChangeScene(sceneName);
}
else
{
error.text = "Error en los datos";
Debug.LogError("Error en los datos");
}
}
UIController.OpenPanel(errorPanel);
}
public GameWindow(DataBase.User user)
{
InitializeComponent();
currentUser = user;
Logic.FrameManager.mainFrame = gameFrm;
Logic.FrameManager.mainFrame.Navigate(new Pages.ChoiceOfDimensionPage(this));
}
/// <summary>
/// Конструктор с параметрами
/// </summary>
/// <param name="product">Объект пользователя из базы данных</param>
public EditUserModel(DataBase.User user)
{
this.Id = user.Id;
this.Login = user.Login;
this.FIO = user.FIO;
this.Password = user.Password;
}
public void AssignExpertsToProblem(int id, [FromBody] int[] expertIds)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAnalytic(_currentUser))
{
return;
}
foreach (var expertIdEstimator in expertIds)
{
foreach (var expertIdEstimated in expertIds)
{
if (expertIdEstimator == expertIdEstimated)
{
continue;
}
var estOnExpertDB = new EstimationOnExpert()
{
IdEstimatedExpert = expertIdEstimated,
IdEstimator = expertIdEstimator,
IdProblem = id,
Value = null
};
DbHelper.CreateEstimationOnExpert(estOnExpertDB);
}
}
}
public List <int> AssignAlternativesToProblem(int id, [FromBody] List <ExpertChoicesModels.Alternative> alternatives)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAnalytic(_currentUser))
{
return(null);
}
var altIds = new List <int>();
var expertIds = DbHelper.GetEstimatorsOfProblem(id);
foreach (var alt in alternatives)
{
var altDb = ModelMapper.ConvertToDBAlternative(alt);
var altId = DbHelper.CreateAlternative(altDb);
altIds.Add(altId);
foreach (var expertId in expertIds)
{
var estOnAlternativeDB = new EstimationOnAlternative()
{
IdEstimatedAlternative = altId,
IdEstimator = expertId,
IdProblem = id,
Value = null
};
DbHelper.CreateEstimationOnAlternative(estOnAlternativeDB);
}
}
return(altIds);
}
public AuthorizationResultModel Authorize()
{
_currentUser = AuthHelper.GetUserFromAuthToken(Request.Headers?.Authorization?.Parameter);
if (_currentUser is null)
{
return(null);
}
var model = new AuthorizationResultModel
{
Email = _currentUser.Email,
IsAuthorized = false,
Role = UserRole.Null
};
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (_currentUser is null)
{
return(model);
}
model.IsAuthorized = _currentUser.IsApproved;
model.Role = (UserRole)_currentUser.Role;
model.FirstName = _currentUser.FirstName;
model.LastName = _currentUser.LastName;
return(model);
}
public int CreateNewProblem([FromBody] ExpertChoicesModels.Problem problemModel)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedExpert(_currentUser))
{
return(-1);
}
return(DbHelper.CreateProblem(ModelMapper.ConvertToDBProblem(problemModel)));
}
public AdminWindow(DataBase.User user)
{
InitializeComponent();
currentUser = user;
adminGrid.Background = new SolidColorBrush(Color.FromRgb(118, 227, 131));
adminImg.Source = new BitmapImage(new Uri(System.IO.Path.GetFullPath("..\\..\\Resources\\Администратор.png")));
backBtn.Background = new SolidColorBrush(Color.FromRgb(73, 140, 81));
showHistoryBtn.Background = new SolidColorBrush(Color.FromRgb(73, 140, 81));
}
public void DeleteUser(int id)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAdmin(_currentUser))
{
return;
}
DbHelper.DeleteUser(id);
}
public ExpertChoicesModels.Expert GetCurrentExpert()
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedExpert(_currentUser))
{
return(null);
}
return(ModelMapper.ConvertToResponseExpert(DbHelper.GetExpertByUserId(_currentUser.IdUser)));
}
public List <ExpertChoicesModels.Problem> CheckForAssignedProblems()
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedExpert(_currentUser))
{
return(null);
}
return(DbHelper.CheckForAssignedProblems(_currentUser.IdUser).Select(dbent => ModelMapper.ConvertToResponseProblem(dbent)).ToList());
}
public List <ExpertChoicesModels.Problem> GetAllProblems()
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAnalytic(_currentUser))
{
return(null);
}
return(DbHelper.GetAllProblems().Select(dbent => ModelMapper.ConvertToResponseProblem(dbent)).ToList());
}
/// <summary>
/// Конструктор с параметрами для инициализации начальных данных в модели вывода
/// </summary>
/// <param name="user">Пользователь</param>
/// <param name="service">Сервис</param>
/// <param name="create">Доступ на создание</param>
/// <param name="read">Доступ на чтение</param>
/// <param name="update">Доступ на изменение</param>
/// <param name="delete">Доступ на удаление</param>
public EditAccessesModel(DataBase.User user, string service, bool create, bool read, bool update, bool delete)
{
this.UserId = user.Id;
this.User = user.Login;
this.Service = service;
this.Create = create;
this.Read = read;
this.Update = update;
this.Delete = delete;
}
public ShowHistoryLoginWindow(DataBase.User user)
{
InitializeComponent();
currentUser = user;
loginDtGrd.ItemsSource = Logic.DBQuery.GetListOfHistory();
backBtn.Background = new SolidColorBrush(Color.FromRgb(73, 140, 81));
sortCmbBx.ItemsSource = new List <string>()
{
"Id", "Логин", "Дата входа"
};
}
public static ExpertChoicesModels.User ConvertToResponseUser(DataBase.User userDB)
{
return(new ExpertChoicesModels.User
{
Email = userDB.Email,
FirstName = userDB.FirstName,
LastName = userDB.LastName,
Id = userDB.IdUser,
Password = null,
Role = (ExpertChoicesModels.UserRole)userDB.Role
});
}
public List <ExpertChoicesModels.User> GetPendingUsers()
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAdmin(_currentUser))
{
return(null);
}
var list = DbHelper.GetPendingUsers();
return(list.Select(userDB => ModelMapper.ConvertToResponseUser(userDB)).ToList());
}
public AddPatientWindow()
{
InitializeComponent();
newUser = new DataBase.User();
newUser.Patient = new DataBase.Patient();
DataContext = newUser;
companyCmbBx.ItemsSource = Logic.DBQuery.GetListInsuranceCompany();
policyTypeCmbBx.ItemsSource = Logic.DBQuery.GetListTypeOfInsurancePolicy();
addPatientBtn.Background = new SolidColorBrush(Color.FromRgb(73, 140, 81));
backBtn.Background = new SolidColorBrush(Color.FromRgb(73, 140, 81));
}
public static bool VerifyUserAuthorizedExpert(DataBase.User user)
{
if (user is null)
{
return(false);
}
if (user.Role == 0)
{
user = DbHelper.GetUser(user.Email, user.Password);
}
return(((ExpertChoicesModels.UserRole)user.Role).HasFlag(ExpertChoicesModels.UserRole.Expert) && user.IsApproved);
}
public void SubmitEstimationsOnAlternatives(int id, int idEstimator, [FromBody] List <EstimationModel> estimations)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedExpert(_currentUser))
{
return;
}
var estimationsDB = ModelMapper.ConvertToDBEstimationAlternative(estimations);
estimationsDB.ForEach(est => est.IdProblem = id);
estimationsDB.ForEach(est => est.IdEstimator = idEstimator);
foreach (var estimationDB in estimationsDB)
{
DbHelper.UpdateEstimationOnAlternative(estimationDB);
}
}
public List <ExpertChoicesModels.Expert> AssignAlternativesToProblem()
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAnalytic(_currentUser))
{
return(null);
}
var experts = new List <ExpertChoicesModels.Expert>();
var expertsDB = DbHelper.GetAllExperts();
foreach (var expertDB in expertsDB)
{
experts.Add(ModelMapper.ConvertToResponseExpert(expertDB));
}
return(experts);
}
public List <ExpertChoicesModels.Expert> CheckForAssignedExpertEstimations(int id)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedExpert(_currentUser))
{
return(null);
}
var assignedEstimationsOnExpert = new List <ExpertChoicesModels.Expert>();
var assignedEstimationsOnExpertDb = DbHelper.CheckForEstimationsOnExperts(_currentUser.IdUser, id);
foreach (var estimation in assignedEstimationsOnExpertDb)
{
var expert = DbHelper.GetExpertById(estimation.IdEstimatedExpert);
assignedEstimationsOnExpert.Add(ModelMapper.ConvertToResponseExpert(expert));
}
return(assignedEstimationsOnExpert);
}
public List <ExpertChoicesModels.Alternative> CheckForAssignedAlternativesEstimations(int id)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedExpert(_currentUser))
{
return(null);
}
var assignedEstimationsOnAlternatives = new List <ExpertChoicesModels.Alternative>();
var assignedEstimationsOnExpertDb = DbHelper.CheckForEstimationsOnAlternative(_currentUser.IdUser, id);
foreach (var estimation in assignedEstimationsOnExpertDb)
{
var alternative = DbHelper.GetAlternativeById(estimation.IdEstimatedAlternative);
assignedEstimationsOnAlternatives.Add(ModelMapper.ConvertToResponseAlternative(alternative));
}
return(assignedEstimationsOnAlternatives);
}
private void EnterTheCabinet(DataBase.User user)
{
switch (user.Role)
{
case 1:
Windows.AdminWindow adminWindow = new Windows.AdminWindow(user);
adminWindow.Title = $"Admin({user.Login})";
Close();
adminWindow.Show();
break;
case 2:
Windows.BookerWindow bookerWindow = new Windows.BookerWindow();
bookerWindow.Title = $"Booker({user.Login})";
Close();
bookerWindow.Show();
break;
case 3:
Windows.LaborantWindow laborantWindow = new Windows.LaborantWindow();
laborantWindow.Title = $"Laborant({user.Login})";
Close();
laborantWindow.Show();
break;
case 4:
Windows.SearcherWindow searcherWindow = new Windows.SearcherWindow();
searcherWindow.Title = $"Searcher({user.Login})";
Close();
searcherWindow.Show();
break;
case 5:
Windows.PatientWindow patientWindow = new Windows.PatientWindow();
patientWindow.Title = $"Patient({user.Login})";
Close();
patientWindow.Show();
break;
}
}
public ProblemDetailsModel GetProblemDetails(int id)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAnalytic(_currentUser))
{
return(null);
}
var dbProblem = DbHelper.GetProblem(id);
var model = new ProblemDetailsModel()
{
Name = dbProblem.Name,
Description = dbProblem.Description,
Id = dbProblem.IdProblem,
Alternatives = new List <ExpertChoicesModels.Alternative>(),
Experts = new List <ExpertChoicesModels.Expert>()
};
model.Alternatives.AddRange(DbHelper.GetAlternativesOfProblem(id).Select(altDb => ModelMapper.ConvertToResponseAlternative(altDb)));
model.Experts.AddRange(DbHelper.GetExpertsOfProblem(id).Select(expDb => ModelMapper.ConvertToResponseExpert(expDb)));
return(model);
}
public void SolveTheProblem(int id)
{
_currentUser = AuthHelper.GetUserFromAuthHeader(Request);
if (!AuthHelper.VerifyUserAuthorizedAnalytic(_currentUser))
{
return;
}
var problem = ModelMapper.ConvertToResponseProblem(DbHelper.GetProblem(id));
var estimationsOnAlternativesDB = DbHelper.GetEstimationsOnAlternatives(id);
var estimationsOnExpertsDB = DbHelper.GetEstimationsOnExpert(id);
foreach (var est in estimationsOnAlternativesDB)
{
if (est.Value is null)
{
return;
}
}
foreach (var est in estimationsOnExpertsDB)
{
if (est.Value is null)
{
return;
}
}
//Gather estimation on alternatives data into problem object
foreach (var estOnAltDB in estimationsOnAlternativesDB.GroupBy(est => est.IdEstimator))
{
problem.AlternativesEstimations.Add(ModelMapper.ConvertToEstimationModel(estOnAltDB.ToList()));
problem.AlternativesEstimations.Last().Estimator = new ExpertChoicesModels.Expert
{
Id = estOnAltDB.Key
};
foreach (var est in estOnAltDB)
{
var altFromDB = DbHelper.GetAlternativeById(est.IdEstimatedAlternative);
var estimatorFromDB = DbHelper.GetExpertById(estOnAltDB.Key);
problem.AlternativesEstimations
.Single(es => es.Estimator.Id == estOnAltDB.Key)
.Estimated
.Single(es => es.Key.Id == altFromDB.IdAlternative)
.Key.Name = altFromDB.Name;
problem.AlternativesEstimations
.Single(es => es.Estimator?.Id == estOnAltDB.Key)
.Estimated
.Single(es => es.Key.Id == altFromDB.IdAlternative)
.Key.Description = altFromDB.Description;
problem.AlternativesEstimations
.Single(es => es.Estimator.Id == estOnAltDB.Key)
.Estimator = ModelMapper.ConvertToResponseExpert(estimatorFromDB);
}
}
//Gather estimation on experts data into problem object
foreach (var estOnExpDB in estimationsOnExpertsDB.GroupBy(est => est.IdEstimator))
{
problem.ExpertsEstimations.Add(ModelMapper.ConvertToEstimationModel(estOnExpDB.ToList()));
problem.ExpertsEstimations.Last().Estimator = new ExpertChoicesModels.Expert
{
Id = estOnExpDB.Key
};
foreach (var est in estOnExpDB)
{
var expFromDB = DbHelper.GetExpertById(est.IdEstimatedExpert);
var estimatorFromDB = DbHelper.GetExpertById(estOnExpDB.Key);
problem.ExpertsEstimations
.Single(es => es.Estimator.Id == estOnExpDB.Key)
.Estimated
.Single(es => es.Key.Id == expFromDB.IdExpert)
.Key.Name = expFromDB.Name;
problem.ExpertsEstimations
.Single(es => es.Estimator.Id == estOnExpDB.Key)
.Estimator = ModelMapper.ConvertToResponseExpert(estimatorFromDB);
}
}
//solve the problem
var problemSolver = new ProblemSolver <
ExpertChoicesModels.Problem,
ExpertChoicesModels.Expert,
ExpertChoicesModels.Expert,
ExpertChoicesModels.Alternative>(problem);
var problemSolution = problemSolver.SolveTheProblem();
//Insert into AlternativeDispersion
foreach (var item in problemSolution.AlternativesDispersion)
{
var altId = DbHelper.GetAlternativeByName(item.Key.Name).IdAlternative;
DbHelper.CreateAlternativeDispersion(new AlternativeDispersion
{
IdAlternative = altId,
IdProblem = problem.Id,
Value = (float)item.Value
});
}
//Insert into AlternativePreferency
foreach (var item in problemSolution.AlternativesPreferency)
{
var altId = DbHelper.GetAlternativeByName(item.Key.Name).IdAlternative;
DbHelper.CreateAlternativePreferency(new AlternativePreferency
{
IdAlternative = altId,
IdProblem = problem.Id,
Value = (float)item.Value
});
}
//Insert into ExpertCompetency
foreach (var item in problemSolution.ExpertsCompetency)
{
var expId = DbHelper.GetExpertByName(item.Key.Name).IdExpert;
DbHelper.CreateExpertCompetency(new ExpertCompetency
{
IdExpert = expId,
IdProblem = problem.Id,
Value = (float)item.Value
});
}
//Insert into ExpertDispersion
foreach (var item in problemSolution.ExpertsDispersion)
{
var expId = DbHelper.GetExpertByName(item.Key.Name).IdExpert;
DbHelper.CreateExpertDispersion(new ExpertDispersion
{
IdExpert = expId,
IdProblem = problem.Id,
Value = (float)item.Value
});
}
}
/// <summary>
/// Конструктор с параметрами
/// </summary>
/// <param name="product">Объект пользователя из базы данных</param>
public DetailsUserModel(DataBase.User user)
{
this.Id = user.Id;
this.Login = user.Login;
this.FIO = user.FIO;
}
/// <summary>
/// Метод-расширение проверяет наличие прав доступа у пользователя для пользователя из базы
/// </summary>
/// <param name="user">Пользователь</param>
/// <param name="service">Сервис, к которому необходим доступ</param>
/// <param name="action">Уровень доступа определяется действием, которое необходимо выполнить, используется стандартная модель CRUD</param>
/// <returns></returns>
public static bool HasPermission(this DataBase.User user, Services service, Actions action)
{
return(HasPermission(user.Login, service, action));
}
