public async Task <int> NoDateRestrictions_ReturnsCorrect(bool isReader, bool isEditor)
{
var unitId = 50;
var userId = 100;
var unitPermissions = new List <UnitPermission>();
if (isReader)
{
unitPermissions.Add(new UnitPermission {
UnitId = unitId, PermissionType = PermissionType.LesNyheter
});
}
if (isEditor)
{
unitPermissions.Add(new UnitPermission {
UnitId = unitId, PermissionType = PermissionType.SkrivNyheter
});
}
A.CallTo(() => CurrentUserContext.Get()).Returns(new UserContext {
UserId = userId
});
A.CallTo(() => AuthorizationService.GetUnitPermissions(A <int> .Ignored, A <int?> .Ignored, A <PermissionType[]> .Ignored)).Returns(unitPermissions);
var result = await NewsFilterService.GetBaseFilter();
return(result.Count());
}
internal CurrentUserScope(CurrentUserProvider currentUserProvider, CurrentUserContext scopedContext)
{
_currentUserProvider = currentUserProvider;
_previousContext = currentUserProvider.Context;
_currentUserProvider.Context = scopedContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="SendC32ViewModel"/> class.
/// </summary>
/// <param name="userDialogService">The user dialog service.</param>
/// <param name="asyncRequestDispatcherFactory">The async request dispatcher factory.</param>
/// <param name="accessControlManager">The access control manager.</param>
/// <param name="commandFactory">The command factory.</param>
/// <param name="eventAggregator">The event aggregator.</param>
/// <param name="popupService">The popup service.</param>
/// <param name="currentUserContextService">The current user context service.</param>
public SendC32ViewModel(
IUserDialogService userDialogService,
IAsyncRequestDispatcherFactory asyncRequestDispatcherFactory,
IAccessControlManager accessControlManager,
ICommandFactory commandFactory,
IEventAggregator eventAggregator,
IPopupService popupService,
ICurrentUserContextService currentUserContextService)
: base(accessControlManager, commandFactory)
{
_userDialogService = userDialogService;
_asyncRequestDispatcherFactory = asyncRequestDispatcherFactory;
_eventAggregator = eventAggregator;
_popupService = popupService;
currentUserContextService.RegisterForContext((cuc, b) => _currentContext = cuc);
// UI Commands
SendC32Command = CommandFactoryHelper
.CreateHelper(this, commandFactory)
.BuildDelegateCommand(() => SendC32Command, ExecuteSendC32);
OpenAddressBookCommand = CommandFactoryHelper
.CreateHelper(this, commandFactory)
.BuildDelegateCommand(() => OpenAddressBookCommand, ExecuteOpenAddressBook);
// Navigation Commands
OpenSendC32ViewCommand = NavigationCommandManager.BuildCommand(() => OpenSendC32ViewCommand, NavigateToOpenSendC32ViewCommand);
_eventAggregator.GetEvent <DirectAddressRecipientSelectedEvent> ().Subscribe(HandleDirectAddressRecipientSelectedEventHandler);
}
public CurrentUserContext GetCurrentUser()
{
var _identity = HttpContext.Current.User.Identity;
if (!_identity.IsAuthenticated)
{
return(null);
}
ApplicationDbContext db = new ApplicationDbContext();
var _userID = HttpContext.Current.User.Identity.GetUserId();
var _supplier = db.Suppliers.Where(x => x.UserID == _userID).FirstOrDefault();
CurrentUserContext _user = new CurrentUserContext
{
UserID = _userID,
UserName = _identity.Name,
SupplierID = _supplier == null ? -1 : _supplier.Id,
PlanEndDate = _supplier == null ? DateTime.Now : _supplier.PlanEndDate,
ProductCount = _supplier == null ? 0 : _supplier.ProductCount,
UserCount = _supplier == null ? 0 : _supplier.UserCount,
PlanId = _supplier == null ? 0 : _supplier.PlanID,
CompanyName = _supplier == null ? "" : _supplier.CompanyName
};
HttpContext.Current.Session["CurrentUserContext"] = _user;
return(_user);
}
/// <summary>
/// Called when [context changed].
/// </summary>
/// <param name="currentUserContext">The current user context.</param>
/// <param name="firstCall">If set to <c>true</c> [first call].</param>
public void OnContextChanged(CurrentUserContext currentUserContext, bool firstCall)
{
if (firstCall || ApplyContextChanges)
{
CurrentUserContext = currentUserContext;
}
ContextChanged(this, new EventArgs());
}
public SecurityService(
IRepository repository,
CurrentUserContext currentUserContext
)
{
_repository = repository;
_currentUserContext = currentUserContext;
}
public static CurrentUserContext CreateUserContext(string user, params string[] roles)
{
var userContext = new CurrentUserContext();
userContext.User = user;
userContext.Roles = roles.ToList();
return(userContext);
}
public TransactionHelperService(CurrentUserContext userContext, ITransactionRepository repository,
IMapper mapper)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_userContext = userContext ?? throw new ArgumentNullException(nameof(userContext));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_specificationFactory = new TransactionSpecificationFactory();
}
public ResourcesController(ILogger <ResourcesController> logger
, CurrentUserContext currentUserContext
, ResourceRepository resourceRepository
)
{
this.logger = logger;
this.currentUserContext = currentUserContext;
this.resourceRepository = resourceRepository;
}
protected void LangMenu_MenuItemClick(object sender, MenuEventArgs e)
{
int languageId = Convert.ToInt32(e.Item.Value);
CurrentUserContext.SetCurrentLanguage(languageId);
// Redirect page in order to change language
Response.Redirect(Request.RawUrl, false);
}
private void ChangeContext(CurrentUserContext currentUserContext, bool isInit = false)
{
lock ( _currentUserContextSync )
{
CurrentUserContext = currentUserContext;
//change context to have new location
_currentUserContextWeakDelegatesManager.Raise(CurrentUserContext, isInit);
}
}
public static CurrentUserContext GetCurrentUserContext(this HttpContext httpContext)
{
var userContextService = httpContext.RequestServices.GetService <ICurrentUserContextService>();
if (userContextService != null)
{
return(userContextService.GetCurrentUserContext());
}
return(CurrentUserContext.Create(httpContext.User.Claims));
}
public PlayerProfileController(ILogger <PlayerProfileController> logger
, CurrentUserContext currentUserContext
, PlayerRepository playerRepository
, PlayerRepositoryWrite playerRepositoryWrite
)
{
this.logger = logger;
this.currentUserContext = currentUserContext;
this.playerRepository = playerRepository;
this.playerRepositoryWrite = playerRepositoryWrite;
}
public AuthenticationController(ILogger <AuthenticationController> logger
, IOptions <BgeOptions> options
, CurrentUserContext currentUserContext
, PlayerRepository playerRepository
, PlayerRepositoryWrite playerRepositoryWrite
)
{
this.options = options;
this.currentUserContext = currentUserContext;
this.playerRepository = playerRepository;
this.playerRepositoryWrite = playerRepositoryWrite;
}
public void SetUp()
{
_context = new TaskterDbContext(new DbContextOptionsBuilder <TaskterDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
_context.Database.EnsureCreated();
_userContext = new CurrentUserContext()
{
UserId = 4
};
_repository = new ProjectTaskEntryRepository(_context, _userContext);
}
public static PermissionCheckContext Create(ControlPointRegistry registry, CurrentUserContext userContext, PermissionCheckRequirement requirement, params string[] permissionIds)
{
var context = new PermissionCheckContext
{
ControlPointRegistry = registry,
Requirement = requirement,
UserContext = userContext
};
context.AddCheckPermissionIds(permissionIds);
return(context);
}
public async Task SetViewModelPropertiesForArticle_SetsTheRequiredViewModelProperties()
{
// Arrange
var user = await CurrentUserContext.GetCurrentUserContext();
// Act
_articleViewModel.SetViewModelPropertiesForArticle(_articleViewModel.Article, _articles.First(), _articleTags, user);
// Assert
_articleViewModel.Article.Author.Following.ShouldBeTrue();
_articleViewModel.Article.Favorited.ShouldBeTrue();
_articleViewModel.Article.TagList.ShouldNotBeEmpty();
}
protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
base.OnActionExecuting(filterContext);
int selectedLanguageId;
if (int.TryParse(Request.Form["SelectedLanguageId"], out selectedLanguageId))
{
CurrentUserContext.SetCurrentLanguage(selectedLanguageId);
CurrentLanguage = CurrentUserContext.CurrentLanguage;
Redirect(Request.RawUrl);
}
}
public void SetUp()
{
_context = new TaskterDbContext(new DbContextOptionsBuilder <TaskterDbContext>()
.UseInMemoryDatabase("InMemoryTaskterDB")
.Options);
_context.Database.EnsureCreated();
var _userContext = new CurrentUserContext()
{
UserId = 4
};
_repository = new ProjectRepository(_context, _userContext);
}
private void AfterLogin(UserIdentity user)
{
CurrentUserContext.Initilize(user);
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(user.Email, this.cbxRemember.Checked, 24 * 60);
// Encrypt the ticket.
string encTicket = FormsAuthentication.Encrypt(ticket);
// Create the cookie.
HttpContext.Current.Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
RedirectAferValidate();
}
public UnitsController(ILogger <UnitsController> logger
, CurrentUserContext currentUserContext
, PlayerRepository playerRepository
, UnitRepository unitRepository
, UnitRepositoryWrite unitRepositoryWrite
, GameDef gameDef
)
{
this.logger = logger;
this.currentUserContext = currentUserContext;
this.playerRepository = playerRepository;
this.unitRepository = unitRepository;
this.unitRepositoryWrite = unitRepositoryWrite;
this.gameDef = gameDef;
}
public async void InvokeAsync_ShouldSetUserIdInCurrentUserContext()
{
var userId = "userId123";
var currentUserContext = new CurrentUserContext();
var httpContext = new DefaultHttpContext();
var identity = new ClaimsIdentity("ApplicationCookie", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, userId));
httpContext.User = new ClaimsPrincipal(identity);
var sut = new UserContextMiddleware(async _ => await Task.Delay(0));
await sut.Invoke(httpContext, currentUserContext);
Assert.Equal(userId, currentUserContext.UserId);
}
public async Task SetViewModelProperties_ForEachArticle_SetsTheRequiredViewModelProperties()
{
// Arrange
var authorToFollow = _articleViewModelList.Articles.FirstOrDefault(a => a.Author.Username == "joey.mckenzie");
authorToFollow.ShouldNotBeNull();
authorToFollow.Author.Following.ShouldBeFalse();
var user = await CurrentUserContext.GetCurrentUserContext();
// Act
_articleViewModelList.SetViewModelProperties(_articles, user, _articleTags);
// Assert
authorToFollow.Author.Following.ShouldBeTrue();
authorToFollow.Favorited.ShouldBeTrue();
authorToFollow.TagList.ShouldNotBeEmpty();
}
public BattleController(ILogger <PlayerRankingController> logger
, GameDef gameDef
, CurrentUserContext currentUserContext
, ScoreRepository scoreRepository
, PlayerRepository playerRepository
, UnitRepository unitRepository
, UnitRepositoryWrite unitRepositoryWrite
)
{
this.logger = logger;
this.gameDef = gameDef;
this.currentUserContext = currentUserContext;
this.scoreRepository = scoreRepository;
this.playerRepository = playerRepository;
this.unitRepository = unitRepository;
this.unitRepositoryWrite = unitRepositoryWrite;
}
private void InitializeUserInformation(UserInformationDto userInformationDto)
{
lock ( _userPermissionsSync )
{
lock ( _currentUserContextSync )
{
_userPermissions.Clear();
foreach (var grantedPermission in userInformationDto.GrantedPermissions)
{
var permission = new Permission {
Name = grantedPermission
};
_userPermissions.Add(permission);
}
var agency = new AgencyContext(
userInformationDto.AgencyKey,
userInformationDto.AgencyDisplayName);
var location = new LocationContext(
userInformationDto.LocationKey,
userInformationDto.LocationDisplayName);
var staff = new StaffContext(
userInformationDto.StaffKey,
userInformationDto.StaffFirstName,
userInformationDto.StaffMiddleName,
userInformationDto.StaffLastName,
userInformationDto.DirectEmailAddress);
var account = new AccountContext(
userInformationDto.AccountKey,
userInformationDto.AccountIdentifier);
var currentUserContext = new CurrentUserContext(
agency,
location,
staff,
account);
ChangeContext(currentUserContext);
_permissionsInitialized = true;
_userPermissionsWeakDelegatesManager.Raise();
}
}
}
public AssetsController(ILogger <AssetsController> logger
, CurrentUserContext currentUserContext
, PlayerRepository playerRepository
, AssetRepository assetRepository
, AssetRepositoryWrite assetRepositoryWrite
, ResourceRepository resourceRepository
, UnitRepository unitRepository
, GameDef gameDef
)
{
this.logger = logger;
this.currentUserContext = currentUserContext;
this.playerRepository = playerRepository;
this.assetRepository = assetRepository;
this.assetRepositoryWrite = assetRepositoryWrite;
this.resourceRepository = resourceRepository;
this.unitRepository = unitRepository;
this.gameDef = gameDef;
}
public ActionResult SignIn(SignInViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
UserIdentity user = Service.Authenticate(model.Email, EncryptionHelper.Encrypt(model.Password));
if (user != null)
{
CurrentUserContext.Initilize(user);
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(user.Email, model.RememberMe, 24 * 60);
// Encrypt the ticket.
string encTicket = FormsAuthentication.Encrypt(ticket);
// Create the cookie.
System.Web.HttpContext.Current.Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
!returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction(FolderController.IndexAction, FolderController.ControllerName));
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
model.CurrentLanguage = CurrentLanguage;
return(View(model));
}
public DemoApiController(CurrentUserContext currentUser)
{
_currentUser = currentUser;
}
public static bool IsLogin(this CurrentUserContext userContext)
{
return(!string.IsNullOrWhiteSpace(userContext.User));
}
public static UnitViewModel ToUnitViewModel(this UnitImmutable unit, UnitRepository unitRepository, CurrentUserContext currentUserContext, GameDef gameDef)
{
var unitDef = gameDef.GetUnitDef(unit.UnitDefId);
if (unitDef == null)
{
throw new InvalidGameDefException($"Unit '{unit.UnitDefId}' not found");
}
return(new UnitViewModel {
UnitId = unit.UnitId.Id,
Definition = UnitDefinitionViewModel.Create(unitDef, unitRepository.PrerequisitesMet(currentUserContext.PlayerId, unitDef)),
Count = unit.Count,
PositionPlayerId = unit.Position?.Id
});
}
public PayerPayeeService(CurrentUserContext userContext, IPayerPayeeRepository repo)
{
_userContext = userContext ?? throw new ArgumentNullException(nameof(userContext));
_repository = repo ?? throw new ArgumentNullException(nameof(repo));
}
