public void Login(string username, string password)
{
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var userRepository = RepositoriesFactory.CreateUserRepository(unitOfWork);
try
{
unitOfWork.BeginTransaction();
var user = userRepository.GetUserByUsername(username);
if (user.IsSamePassword(password))
{
LoggedInUserId = user.Id;
_isUserLoggedIn = true;
unitOfWork.Commit();
ShowMainWindow();
}
else
{
throw new Exception("Username or password is not correct!");
}
}
catch (Exception ex)
{
unitOfWork.Rollback();
_isUserLoggedIn = false;
ShowLoginWindow();
MessageBox.Show(ex.Message, "TravelBuddy");
}
}
public void OpenTravelListWindow()
{
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var userRepository = RepositoriesFactory.CreateUserRepository(unitOfWork);
var travelController = new TravelController(this, _formsFactory);
try
{
unitOfWork.BeginTransaction();
var user = userRepository.GetUser(LoggedInUserId);
var travels = new List <Travel>(user.Travels);
unitOfWork.Commit();
var travelListView = _formsFactory.CreateTravelListView(travelController, travels);
travelListView.ShowModaless();
}
catch (Exception ex)
{
unitOfWork.Rollback();
ShowRegisterWindow();
MessageBox.Show(ex.Message, "TravelBuddy");
}
}
public void LoadDefaultModel()
{
if (_defaultModelLoaded != false)
{
return;
}
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var currencyRepository = RepositoriesFactory.CreateCurrencyRepository(unitOfWork);
try
{
unitOfWork.BeginTransaction();
currencyRepository.CreateCurrenciesIfNoneExist();
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
MessageBox.Show(ex.Message, "TravelBuddy");
}
_defaultModelLoaded = true;
}
public ClientDto GetById(int id, string userName)
{
Logger.LogInformation(String.Format("Try to get client by id {0}", id));
ClientDto toReturn = null;
using (var context = RepositoriesFactory.CreateContext())
{
var clientRepo = RepositoriesFactory.GetClientRepository(context);
var client = clientRepo.GetById(id);
if (client == null || !client.IsValid)
{
throw new DaOAuthNotFoundException();
}
// we need to remove scopes from invalid ressources servers
if (client.ClientsScopes != null && client.ClientsScopes.Count() > 0)
{
var invalidsRs = ExtractInvalidRessourceServerIds(context);
client.ClientsScopes = client.ClientsScopes.ToList().Where(cs => !invalidsRs.Contains(cs.Scope.RessourceServerId)).ToList();
}
toReturn = client.ToDto(client.UserCreator.UserName.Equals(userName));
}
return(toReturn);
}
public void Register(string username, string email, string password)
{
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var userRepository = RepositoriesFactory.CreateUserRepository(unitOfWork);
try
{
unitOfWork.BeginTransaction();
var user = new User
{
Username = username,
Email = email,
};
user.SetPassword(password);
userRepository.AddUser(user);
LoggedInUserId = user.Id;
_isUserLoggedIn = true;
unitOfWork.Commit();
ShowMainWindow();
}
catch (Exception ex)
{
unitOfWork.Rollback();
_isUserLoggedIn = false;
ShowRegisterWindow();
MessageBox.Show(ex.Message, "TravelBuddy");
}
}
public static IServices Create(IServiceDependencies dependencies)
{
IRepositories repositories;
IServiceContext context;
if (!dependencies.UseTestRepositories)
{
repositories = RepositoriesFactory.Create(dependencies.RepositoriesConfig);
context = new ServiceContext(dependencies, repositories);
// TODO -- Implement Integration Test Repositories/Services
//if (dependencies.UseIntegrationTestRepositories)
//{
// return new TestServices(context);
//}
//else
//{
// return new Implementation.Services(context);
//}
return(new Implementation.Services(context));
}
else
{
// TODO -- Implement Test Repositories/Services
//repositories = TestRepositoriesFactory.Create();
//context = new ServiceContext(dependencies, repositories);
//return new TestServices(context);
repositories = RepositoriesFactory.Create(dependencies.RepositoriesConfig);
context = new ServiceContext(dependencies, repositories);
return(new Implementation.Services(context));
}
}
public void FindAndApplyCustomer(uint number, Department department)
{
if (department == null)
{
throw new Exception("Отделение для поиска не задано");
}
var operationName = $"Поиск плательщика за электроэнергию {number}, отделение \"{department.Code} {department.Name}\"";
Log.Info($"Запуск -> {operationName}");
var potencialCustomers = RepositoriesFactory.Get <EnergyCustomer>().Filter(customer => customer.Number == number && customer.IsActive);
Customer.Value = potencialCustomers.FirstOrDefault(customer => customer.Department.Id == department.Id)
?? potencialCustomers.FirstOrDefault(customer => customer.Department.Code == department.Code);
if (Customer.Value == null)
{
Log.Info($"Не найдено -> {operationName}");
}
else
{
Log.Info($"Найдено -> {operationName}");
}
}
public void SaveEditedTravel(EditTravelViewModel travelModel)
{
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var travelRepository = RepositoriesFactory.CreateTravelRepository(unitOfWork);
try
{
unitOfWork.BeginTransaction();
var travel = travelRepository.GetTravel(travelModel.Id);
travel.Name = travelModel.Name;
travel.Description = travelModel.Description;
travel.DateStart = travelModel.DateStart;
travel.DateEnd = travelModel.DateEnd;
travel.Budget = travelModel.Budget;
travelRepository.UpdateTravel(travel);
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
MessageBox.Show(ex.Message, "TravelBuddy");
}
}
public void AddTravel(AddTravelViewModel model)
{
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var userRepository = RepositoriesFactory.CreateUserRepository(unitOfWork);
var travelRepository = RepositoriesFactory.CreateTravelRepository(unitOfWork);
try
{
unitOfWork.BeginTransaction();
var user = userRepository.GetUser(_mainController.LoggedInUserId);
var travel = new Travel
{
Name = model.Name,
Description = model.Description,
DateStart = model.DateStart,
DateEnd = model.DateEnd,
Budget = model.Budget,
Traveller = user
};
travelRepository.AddTravel(travel);
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
MessageBox.Show(ex.Message, "TravelBuddy");
}
}
public void OpenTravelDetails(Guid travelId)
{
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var travelRepository = RepositoriesFactory.CreateTravelRepository(unitOfWork);
try
{
unitOfWork.BeginTransaction();
var travel = travelRepository.GetTravel(travelId);
var travelModal = new TravelViewModel
{
Id = travel.Id,
Name = travel.Name,
Description = travel.Description,
DateStart = travel.DateStart,
DateEnd = travel.DateEnd,
Budget = travel.Budget
};
unitOfWork.Commit();
var travelDetailsView = _formsFactory.CreateTravelDetailsView(this, travelModal);
travelDetailsView.ShowModaless();
}
catch (Exception ex)
{
unitOfWork.Rollback();
MessageBox.Show(ex.Message, "TravelBuddy");
}
}
public void AddPreliminaryActivity(AddPreliminaryActivityViewModel travelItemViewModel, Guid travelId)
{
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var travelRepository = RepositoriesFactory.CreateTravelRepository(unitOfWork);
try
{
unitOfWork.BeginTransaction();
var travel = travelRepository.GetTravel(travelId);
travel.PreliminaryActivityList.Add(new PreliminaryActivity
{
Name = travelItemViewModel.Name,
Description = travelItemViewModel.Description,
IsCompleted = travelItemViewModel.IsCompleted
});
travelRepository.UpdateTravel(travel);
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
MessageBox.Show(ex.Message, "TravelBuddy");
}
}
public ICollection <ProgramDTO> GetUsersPrograms(ProgramDTO newProgram, String userName)
{
ActionResponse response = new ActionResponse();
ProgramRepository repository = RepositoriesFactory.CreateRepository <ProgramRepository, Program>();
int UserId = GetCurrentUser().UserId;
ICollection <Program> wantedPrograms;
if (GetCurrentUser().Permission == (int)Enums.PermissionsType.Admin)
{
wantedPrograms = repository.GetALL();
}
else
{
wantedPrograms =
repository.Query().Where(CurrProgram => CurrProgram.UserPrograms.Any(currUser => currUser.UserId == UserId)).ToList();
}
ICollection <ProgramDTO> ProgramDrills =
wantedPrograms.Select <Program, ProgramDTO>(currProgram => ConvertEntityTODTO(currProgram)).ToList();
return(ProgramDrills);
}
private string GenerateAndSaveCode(string clientPublicId, string userName, string scope)
{
var codeValue = RandomService.GenerateRandomString(CodeLenght);
using (var context = RepositoriesFactory.CreateContext())
{
var userClientRepo = RepositoriesFactory.GetUserClientRepository(context);
var codeRepo = RepositoriesFactory.GetCodeRepository(context);
var uc = userClientRepo.GetUserClientByClientPublicIdAndUserName(clientPublicId, userName);
codeRepo.Add(new Domain.Code()
{
CodeValue = codeValue,
ExpirationTimeStamp = new DateTimeOffset(DateTime.Now.AddSeconds(Configuration.CodeDurationInSeconds)).ToUnixTimeSeconds(),
IsValid = true,
Scope = scope,
UserClientId = uc.Id
});
context.Commit();
}
return(codeValue);
}
private ActionResponse ValidateDrill(DrillDTO drill, bool isUpdate = false)
{
DrillsRepository repository = RepositoriesFactory.CreateRepository <DrillsRepository, Drill>();
MuscleGroupsRepository muscleGroupRep = RepositoriesFactory.CreateRepository <MuscleGroupsRepository, MuscleGroup>();
if (repository.Query().Any(currDrill => currDrill.DrillId != drill.Id && currDrill.Name == drill.Name))
{
return(new ActionResponse()
{
CompletedSuccessfully = false,
ErrorMessage = "A drill with the given name already exists"
});
}
bool doAllMuscleGroupsExist = drill.MuscleGroups.All(currNewMuscleGroup => {
return(muscleGroupRep.Query().Any(CurrMuscleGroup => CurrMuscleGroup.MuscleGroupId == currNewMuscleGroup.Id));
});
if (!doAllMuscleGroupsExist)
{
return(new ActionResponse()
{
CompletedSuccessfully = false,
ErrorMessage = "None existing muscle group"
});
}
return(null);
}
private ActionResponse CanUserEditProgram(int ProgramId)
{
Program wantedProgram = RepositoriesFactory.CreateRepository <ProgramRepository, Program>()
.Query().FirstOrDefault(currProgram => currProgram.ProgramId == ProgramId);
if (wantedProgram == null)
{
return(new ActionResponse()
{
ErrorMessage = "Wanted Program does not exists", CompletedSuccessfully = false
});
}
if (!(GetCurrentUser().Permission == (int)Enums.PermissionsType.Admin))
{
if (!wantedProgram.UserPrograms.Any(currUserProgram => currUserProgram.UserId == GetCurrentUser().UserId))
{
return(new ActionResponse()
{
ErrorMessage = "The given user does not have permissions to update the given program", CompletedSuccessfully = false
});
}
}
return(null);
}
private ActionResponse CanUserEditDrill(int drillId)
{
Drill wantedDrill = RepositoriesFactory.CreateRepository <DrillsRepository, Drill>()
.Query().FirstOrDefault(currDrill => currDrill.DrillId == drillId);
if (wantedDrill == null)
{
return(new ActionResponse()
{
ErrorMessage = "Wanted drill does not exists", CompletedSuccessfully = false
});
}
if (!(GetCurrentUser().Permission == (int)Enums.PermissionsType.Admin))
{
if (wantedDrill.CreatorUserId != GetCurrentUser().UserId)
{
return(new ActionResponse()
{
ErrorMessage = "The given user does not have permissions to update the given drill", CompletedSuccessfully = false
});
}
}
return(null);
}
public void DeleteReturnUrl(DeleteReturnUrlDto toDelete)
{
this.Validate(toDelete);
var resource = this.GetErrorStringLocalizer();
using (var context = RepositoriesFactory.CreateContext())
{
var returnUrlRepo = RepositoriesFactory.GetClientReturnUrlRepository(context);
var myReturnUrl = returnUrlRepo.GetById(toDelete.IdReturnUrl);
if (myReturnUrl == null)
{
throw new DaOAuthServiceException(resource["DeleteReturnUrlUnknowReturnUrl"]);
}
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByUserName(toDelete.UserName);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(resource["DeleteReturnUrlInvalidUser"]);
}
var ucRepo = RepositoriesFactory.GetUserClientRepository(context);
var uc = ucRepo.GetUserClientByClientPublicIdAndUserName(myReturnUrl.Client.PublicId, toDelete.UserName);
if (uc == null)
{
throw new DaOAuthServiceException(resource["DeleteReturnUrlBadUserNameOrClientId"]);
}
returnUrlRepo.Delete(myReturnUrl);
context.Commit();
}
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
return;
}
try
{
Region = RepositoriesFactory.Get <Region>().Get(region => region.Id == Config.CurrentRegionId);
if (Region != null)
{
lblRegionName.Content = Region.Name ?? string.Empty;
UpdateDepartments();
GlobalEvents.OnDepartmentsChanged += UpdateDepartments;
}
else
{
lblRegionName.Content = "Район не задан";
lblRegionName.Foreground = Brushes.Red;
cbDepartmentSelector.IsEnabled = false;
}
}
catch (Exception ex)
{
var message = "Ошибка загрузки департаметов.";
Log.Error(message, ex);
Message.Error(message);
}
}
public ActionResult SetState(int id, RentalState?state, bool redirectToIndex = false)
{
if (state == null)
{
return(BadRequest());
}
var renting = this.RepositoriesFactory.Rentings.GetById(id);
if (renting == null)
{
return(NotFound());
}
renting.State = state.Value;
RepositoriesFactory.SaveChanges();
if (state == RentalState.Canceled)
{
var result = this.sender.SendRentingCanceled(renting, this.CurrentUser, this.MicrosoftAccessToken).Result;
}
if (redirectToIndex)
{
return(RedirectToAction("Index", "Home"));
}
return(Content("OK"));
}
protected override bool TryUpdateExistingItem(DbfArticle dbfArticle)
{
var existingArticle = RepositoriesFactory.Get <Article>().Get(article => article.Code == dbfArticle.Code);
if (existingArticle == null)
{
return(false);
}
existingArticle.Name = dbfArticle.Name ?? string.Empty;
existingArticle.Barcode = dbfArticle.Barcode ?? string.Empty;
existingArticle.IsActive = true;
var articlePrice = existingArticle.ArticlePrices.FirstOrDefault(price =>
price.ArticlePriceType == PriceType && price.EntryDate == dbfArticle.EntryDate);
if (articlePrice != null)
{
articlePrice.Value = dbfArticle.Price;
return(true);
}
var newArticlePrice = new ArticlePrice
{
Article = existingArticle,
ArticlePriceType = PriceType,
EntryDate = dbfArticle.EntryDate,
Value = dbfArticle.Price
};
existingArticle.ArticlePrices.Add(newArticlePrice);
return(true);
}
public void DesactivateUser(string userName)
{
Logger.LogInformation($"Try to desactivate user {userName}");
using (var c = RepositoriesFactory.CreateContext())
{
var repo = RepositoriesFactory.GetUserRepository(c);
var user = repo.GetByUserName(userName);
var local = this.GetErrorStringLocalizer();
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(local["DeleteUserNoUserFound"]);
}
user.IsValid = false;
repo.Update(user);
var ucRepo = RepositoriesFactory.GetUserClientRepository(c);
foreach (var uc in ucRepo.GetAllByCriterias(user.UserName, null, null, null, 0, Int32.MaxValue))
{
uc.RefreshToken = String.Empty;
ucRepo.Update(uc);
}
c.Commit();
}
}
public void SendMailLostPassword(LostPasswordDto infos)
{
Logger.LogInformation($"Send a mail password lost to {infos.Email}");
Validate(infos);
using (var context = RepositoriesFactory.CreateContext())
{
var errorResource = this.GetErrorStringLocalizer();
var mailResource = this.GetMailStringLocalizer();
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByEmail(infos.Email);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(errorResource["SendMailLostPasswordUserNoUserFound"]);
}
var myToken = JwtService.GenerateMailToken(user.UserName);
var link = new Uri(String.Format(Configuration.GetNewPasswordPageUrl, myToken.Token));
MailService.SendEmail(new SendEmailDto()
{
Body = String.Format(mailResource["MailLostPasswordBody"], link.AbsoluteUri),
IsHtml = true,
Receviers = new Dictionary <string, string>()
{
{ user.EMail, user.EMail }
},
Sender = new KeyValuePair <string, string>("*****@*****.**", "no reply"),
Subject = mailResource["MailLostPasswordSubject"]
});
}
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded && DomainUserExists(null, model.Email))
{
// update domain model User
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var userRepository = RepositoriesFactory.CreateUserRepository(unitOfWork);
unitOfWork.BeginTransaction();
var domainUser = userRepository.GetUserByEmail(model.Email);
domainUser.SetPassword(model.Password);
unitOfWork.Commit();
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
AddErrors(result);
return(View());
}
public async Task <IActionResult> Create(AddTravelViewModel viewModel)
{
var travel = viewModel.ToTravel();
var user = await GetCurrentDomainUserAsync();
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var userRepository = RepositoriesFactory.CreateUserRepository(unitOfWork);
var travelRepository = RepositoriesFactory.CreateTravelRepository(unitOfWork);
var currencyRepository = RepositoriesFactory.CreateCurrencyRepository(unitOfWork);
unitOfWork.BeginTransaction();
travel.Traveller = userRepository.GetUser(user.Id);
var currency = currencyRepository.GetById(viewModel.BudgetCurrencyId);
if (viewModel.BudgetValue > 0 && currency != null)
{
travel.Budget = new MoneyValue
{
Value = viewModel.BudgetValue,
Currency = currency
};
}
travelRepository.AddTravel(travel);
unitOfWork.Commit();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(EditTravelViewModel viewModel)
{
var user = await GetCurrentDomainUserAsync();
var unitOfWork = UnitOfWorkFactory.CreateUnitOfWork();
var travelRepository = RepositoriesFactory.CreateTravelRepository(unitOfWork);
var currencyRepository = RepositoriesFactory.CreateCurrencyRepository(unitOfWork);
unitOfWork.BeginTransaction();
var travel = travelRepository.GetTravel(viewModel.Id);
var currency = currencyRepository.GetById(viewModel.BudgetCurrencyId);
travel.Name = viewModel.Name;
travel.DateStart = viewModel.DateStart;
travel.DateEnd = viewModel.DateEnd;
travel.Description = viewModel.Description;
if (viewModel.BudgetValue > 0 && currency != null)
{
travel.Budget = new MoneyValue
{
Value = viewModel.BudgetValue,
Currency = currency
};
}
travelRepository.UpdateTravel(travel);
unitOfWork.Commit();
return(RedirectToAction("Index"));
}
private bool Authorize(HttpActionContext actionContext)
{
try
{
IEnumerable <String> AuthenticationHeaders;
actionContext.Request.Headers.TryGetValues(TokenManager.TOKEN_HEADER_NAME, out AuthenticationHeaders);
String token = AuthenticationHeaders.First();
String userName = TokenManager.ExtractUserNameFromToken(token);
String timeStamp = TokenManager.ExtractUserTimesatmpFromToken(token);
User WantedUser = RepositoriesFactory.CreateRepository <UsersRepository, User>()
.Query().FirstOrDefault <User>(currUser => currUser.UserName == userName);
if (WantedUser == null)
{
return(false);
}
else if (!_allowedPermissionTypes.Contains(WantedUser.Permission))
{
return(false);
}
String hashedPassword = WantedUser.Password;
return(TokenManager.IsTokenValid(token, userName, hashedPassword, TokenManager.GetAccesseingClientIp(actionContext.Request), timeStamp));
}
catch (Exception e)
{
return(false);
}
}
private bool CheckIfCodeIsValid(string clientPublicId, string scope, string codeValue, IContext context, out string userName)
{
bool IsValid(Code code)
{
if (code == null)
{
return(false);
}
if (!code.IsValid)
{
return(false);
}
if (code.ExpirationTimeStamp < new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds())
{
return(false);
}
if (!String.IsNullOrWhiteSpace(code.Scope) && !String.IsNullOrWhiteSpace(scope))
{
IList <string> scopes = scope.Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(c => c.ToUpper()).ToList();
IList <string> codeScopes = code.Scope.Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(c => c.ToUpper()).ToList();
foreach (var s in scopes)
{
if (!codeScopes.Contains(s))
{
return(false);
}
}
}
return(code.UserClient.Client.PublicId.Equals(clientPublicId, StringComparison.Ordinal));
}
userName = String.Empty;
var toReturn = true;
var codeRepo = RepositoriesFactory.GetCodeRepository(context);
var myCode = codeRepo.GetByCode(codeValue);
if (myCode == null)
{
return(false);
}
if (!IsValid(myCode))
{
toReturn = false;
}
else
{
myCode.IsValid = false;
codeRepo.Update(myCode);
}
userName = myCode.UserClient.User.UserName;
return(toReturn);
}
public ActionResponse UpdateProgram(ProgramDTO program)
{
ActionResponse response = ValidateProgram(program, true);
if (response != null)
{
return(response);
}
response = CanUserEditProgram(program.Id);
if (response != null)
{
return(response);
}
Program programForUpdate = ConvertDTOToEntity(program);
ProgramRepository programRepository = RepositoriesFactory.CreateRepository <ProgramRepository, Program>();
Program existingProgram = programRepository.Get(programForUpdate.ProgramId);
existingProgram.ProgramName = programForUpdate.ProgramName;
foreach (ProgramDrill currDrill in programForUpdate.ProgramDrills)
{
ProgramDrill existingProgramDrill =
existingProgram.ProgramDrills.FirstOrDefault(currProgramDrill => currProgramDrill.Id == currDrill.Id);
if (existingProgramDrill == null)
{
existingProgram.ProgramDrills.Add(currDrill);
}
else
{
foreach (Set currSet in currDrill.Sets)
{
Set existingSet =
existingProgramDrill.Sets.FirstOrDefault(currExistingSet => currExistingSet.SetId == currSet.SetId);
if (existingSet == null)
{
existingProgramDrill.Sets.Add(currSet);
}
else
{
existingSet.Repetitions = currSet.Repetitions;
existingSet.Weight = currSet.Weight;
existingSet.Repetitions = currSet.Repetitions;
}
}
}
}
programRepository.Update(existingProgram);
return(new ActionResponse()
{
CompletedSuccessfully = true
});
}
private bool CheckIfUserHasAuthorizeOrDeniedClientAccess(string clientPublicId, string userName)
{
using (var context = RepositoriesFactory.CreateContext())
{
var clientUserRepo = RepositoriesFactory.GetUserClientRepository(context);
return(clientUserRepo.GetUserClientByClientPublicIdAndUserName(clientPublicId, userName) != null);
}
}
public ICollection <UserDTO> GetAllUsers()
{
return(RepositoriesFactory.CreateRepository <UsersRepository, User>().GetALL()
.Select <User, UserDTO>(currUser => new UserDTO()
{
Name = currUser.UserName, Permission = currUser.Permission, UserId = currUser.UserId
}).ToList());
}
