public AccountController(IOpenIdMembershipService openIdMembershipService, IAuthenticationProvider authenticationProvider, IUserService userService, IUserProvider userProvider)
{
this.openIdMembershipService = openIdMembershipService;
this.authenticationProvider = authenticationProvider;
this.userService = userService;
this.userProvider = userProvider;
}
public void ConfigureOAuth(IAppBuilder app, IUserProvider userProvider)
{
var oAuthServerOptions = new OAuthAuthorizationServerOptions()
{
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/api/v1/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(7),
Provider = new SimpleAuthorizationServerProvider(userProvider)
};
app.Use(async (context, next) =>
{
if (context.Request.QueryString.HasValue)
{
if (string.IsNullOrWhiteSpace(context.Request.Headers.Get("Authorization")))
{
var queryString = HttpUtility.ParseQueryString(context.Request.QueryString.Value);
string token = queryString.Get("access_token");
if (!string.IsNullOrWhiteSpace(token))
{
context.Request.Headers.Add("Authorization", new[] { string.Format("Bearer {0}", token) });
}
}
}
await next.Invoke();
});
// Token Generation
app.UseOAuthAuthorizationServer(oAuthServerOptions);
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
}
public bool IsAuthorized(IRequestContext requestContext, IUserProvider userProvider, UserRole userRole)
{
if (userRole == UserRole.None)
{
userRole = UserRole.ReadOnly;
}
string userName = requestContext.UserName,
password = requestContext.Password;
if (userName == null || password == null)
{
return false;
}
var ip = GetIp(true);
/*
if (ip != requestContext.ClientId)
{
return false;
}
* */
HttpContext.Current.Trace.Write("requestContext.ClientId = " + requestContext.ClientId);
HttpContext.Current.Trace.Write("ip = " + ip);
var result = userProvider.Validate(userName, password);
return result != null && result.Result;
}
public CategoryController(ICategoryService categoryService,
IUserProvider userProvider,
IPermissionService permissionService)
: base(userProvider, permissionService) {
this.categoryService = categoryService;
}
public void SetUp()
{
new RegisterRoutes().Execute();
_userProvider = MockRepository.GenerateMock<IUserProvider>();
_actionExecuting = MockRepository.GenerateMock<ActionExecutingContext>();
_filter = new InGameFilter(_userProvider);
}
public BaseManager(IUserProvider userProvider)
{
if (userProvider == null)
{
throw new ArgumentNullException("userProvider");
}
this._userProvider = userProvider;
}
public PlayService(IUnitOfWork unitOfWork, IUserProvider userProvider, IVisibilityModifierFactory visibilityModifierFactory,
IAttackService attackService,
IMapTemplateProvider mapTemplateProvider,
IRandomGen randomGen)
: base(unitOfWork, userProvider, mapTemplateProvider, visibilityModifierFactory)
{
this.attackService = attackService;
this.randomGen = randomGen;
}
public ForumController(ICategoryService categoryService,
IForumService forumService,
IUserProvider userProvider,
IPermissionService permissionService)
: base(userProvider, permissionService) {
this.categoryService = categoryService;
this.forumService = forumService;
}
public void setUserProvider(IUserProvider up) {
if(_userProvider == null && _currentUser == null) {
_userProvider = up;
_currentUser = _userProvider.getCurrentUser();
}
else {
throw new Exception("User provider can't be changed runtime!");
}
}
public void SetUp()
{
Init();
_account = new Account {FirstName = "FName"};
_userProvider = MockRepository.GenerateMock<IUserProvider>();
_userProvider.Stub(m => m.CurrentAccount()).Return(_account);
_accountBinder = new AccountBinder(_userProvider);
_valueProvider.Stub(m => m.GetValue(PropertyName)).Return(new ValueProviderResult(null, null, CultureInfo.CurrentUICulture));
}
public IToggleChecker Create()
{
if (_userProvider == null)
_userProvider = new NullUserProvider();
if(_defaultToggleSpecification==null)
_defaultToggleSpecification = new FalseSpecification();
var featureProvider = _featureProviderFactory.Create();
return new ToggleChecker(featureProvider, _defaultToggleSpecification, _userProvider);
}
public BaseGameService(
IUnitOfWork unitOfWork,
IUserProvider userProvider,
IMapTemplateProvider mapTemplateProvider,
IVisibilityModifierFactory visibilityModifierFactory)
: base(unitOfWork, userProvider)
{
this.mapTemplateProvider = mapTemplateProvider;
this.visibilityModifierFactory = visibilityModifierFactory;
}
public void SetUp()
{
Init();
_player = new Player { Name = "Name" };
_userProvider = MockRepository.GenerateMock<IUserProvider>();
_userProvider.Stub(m => m.CurrentPlayer()).Return(_player);
_playerBinder = new PlayerBinder(_userProvider);
_valueProvider.Stub(m => m.GetValue(PropertyName)).Return(new ValueProviderResult(null, null, CultureInfo.CurrentUICulture));
}
/// <summary>
/// Constructor.
/// </summary>
public BaseControllerArgs(
ILogContext logContext,
IIdentityProvider identityProvider,
IUserProvider userProvider,
ITimeZoneProvider timeZoneProvider)
{
LogContext = logContext;
IdentityProvider = identityProvider;
UserProvider = userProvider;
TimeZoneProvider = timeZoneProvider;
}
public IndexViewModelMapper(
IUserProvider userProvider,
IBookingRepository bookingService,
ICustomerServiceProxy customerServiceProxy,
IVehicleServiceProxy vehicleServiceProxy)
{
_userProvider = userProvider;
_bookingService = bookingService;
_customerServiceProxy = customerServiceProxy;
_vehicleServiceProxy = vehicleServiceProxy;
}
/// <summary>
/// Initializes a new <c>GablarskiServer</c> instance.
/// </summary>
/// <param name="settings">The settings for the server, providing name, description, etc.</param>
/// <param name="authProvider">The user authentication provider for the server to use.</param>
/// <param name="permissionProvider">The user permissions provider for the server to use.</param>
/// <param name="channelProvider">The channel provider for the server to use.</param>
public GablarskiServer(ServerSettings settings, IUserProvider authProvider, IPermissionsProvider permissionProvider, IChannelProvider channelProvider)
: this(settings)
{
this.authProvider = authProvider;
this.permissionProvider = permissionProvider;
this.permissionProvider.PermissionsChanged += OnPermissionsChanged;
this.channelProvider = channelProvider;
SetupHandlers();
}
public FollowerService(IFollowForumRepository forumRepo,
IFollowTopicRepository topicRepo,
IPermissionService permService,
IUserProvider userProvider,
ILogger logger) {
this.forumRepo = forumRepo;
this.topicRepo = topicRepo;
this.logger = logger;
this.userProvider = userProvider;
this.permService = permService;
}
public CategoryService(IUserProvider userProvider,
ICategoryRepository categoryRepo,
IEventPublisher eventPublisher,
ILogger logger,
IPermissionService permService) {
this.categoryRepo = categoryRepo;
this.userProvider = userProvider;
this.eventPublisher = eventPublisher;
this.logger = logger;
this.permService = permService;
}
public ServerProviders(IChannelProvider channels, IUserProvider auth, IPermissionsProvider permissions, IEnumerable<IConnectionProvider> cproviders)
: this(cproviders)
{
if (channels == null)
throw new ArgumentNullException ("channels");
if (auth == null)
throw new ArgumentNullException ("auth");
if (permissions == null)
throw new ArgumentNullException ("permissions");
Channels = channels;
Users = auth;
Permissions = permissions;
}
internal ServerInfo(ServerSettings settings, IUserProvider userProvider)
{
if (settings == null)
throw new ArgumentNullException ("settings");
if (userProvider == null)
throw new ArgumentNullException ("userProvider");
Name = settings.Name;
Description = settings.Description;
Logo = settings.ServerLogo;
Passworded = !String.IsNullOrEmpty (settings.ServerPassword);
RegistrationMode = (userProvider.UpdateSupported) ? userProvider.RegistrationMode : UserRegistrationMode.None;
if (RegistrationMode != UserRegistrationMode.None)
RegistrationContent = userProvider.RegistrationContent;
}
public MainViewModel(IReactiveTrader reactiveTrader,
Func<CurrencyPairStateDto, ICurrencyPairViewModel> ccyViewModelFactory,
IUserProvider userProvider,
IConfigurationProvider configurationProvider,
IConcurrencyService concurrencyService)
{
_reactiveTrader = reactiveTrader;
_ccyViewModelFactory = ccyViewModelFactory;
_userProvider = userProvider;
_configurationProvider = configurationProvider;
_concurrencyService = concurrencyService;
RefreshCommand = new DelegateCommand(RefreshData);
CurrencyPairs = new ObservableCollection<ICurrencyPairViewModel>();
ObserveThroughputs();
}
public DefaultApplicationServices(IUserProvider userProvider,
IHttpContextProvider httpContextProvider,
IConfigurationProvider configurationProvider,
IClientFactory<IEntryClient> entryService,
IMapper mapper)
{
Guard.IsNotNull(userProvider, "userProvider");
Guard.IsNotNull(httpContextProvider, "httpContextProvider");
Guard.IsNotNull(configurationProvider, "configurationProvider");
Guard.IsNotNull(entryService, "entryService");
Guard.IsNotNull(mapper, "mapper");
this.userProvider = userProvider;
this.httpContextProvider = httpContextProvider;
this.configurationProvider = configurationProvider;
this.entryService = entryService;
this.mapper = mapper;
}
public PostService(IUserProvider userProvider,
IForumRepository forumRepo,
ITopicRepository topicRepo,
IPostRepository postRepo,
IEventPublisher eventPublisher,
ILogger logger,
IPermissionService permService,
IForumConfigurationService confService) {
this.userProvider = userProvider;
this.postRepo = postRepo;
this.topicRepo = topicRepo;
this.forumRepo = forumRepo;
this.logger = logger;
this.eventPublisher = eventPublisher;
this.permService = permService;
this.confService = confService;
}
public ForumService(IUserProvider userProvider,
ICategoryRepository categoryRepo,
IForumRepository forumRepo,
ITopicRepository topicRepo,
IPostRepository postRepo,
IEventPublisher eventPublisher,
ILogger logger,
IPermissionService permService) {
this.userProvider = userProvider;
this.categoryRepo = categoryRepo;
this.forumRepo = forumRepo;
this.logger = logger;
this.eventPublisher = eventPublisher;
this.permService = permService;
this.topicRepo = topicRepo;
this.postRepo = postRepo;
}
public SelectUserModel()
: base("SelectUserForDM")
{
provider = Dependency.Resolve<IUserProvider>();
provider.GetFollowers = true;
provider.GetFollowing = false;
provider.Finished += (sender, e) => IsLoading = false;
provider.Error += (sender, e) =>
{
IsLoading = false;
MessageService.ShowError(Localization.Resources.ErrorDownloadingUsers);
};
Collection = new CollectionViewSource();
Collection.Source = provider.Users;
Collection.SortDescriptions.Add(new SortDescription("ScreenName", System.ComponentModel.ListSortDirection.Ascending));
Accounts = Config.Accounts;
goNext = new DelegateCommand((obj) =>
{
DataTransfer.ReplyingDM = true;
Navigate(new Uri("/Pages/NewTweet.xaml?removeBack=1", UriKind.Relative));
}, (obj) =>
{
return Destinatary != null && Sender != null;
});
this.PropertyChanged += (sender, e) =>
{
if (e.PropertyName == "Destinatary")
DestinataryUpdated();
else if (e.PropertyName == "Sender")
SenderUpdated();
else if (e.PropertyName == "UserFilter")
UserFilterUpdated();
};
}
public FlwInjDayController(PDMContext context, IUserProvider userProvider, ILoggerFactory loggerFactory)
{
_db = context;
_userProvider = userProvider;
_logger = loggerFactory.CreateLogger("FlwInjDayController");
}
public PanacheSoftwareServiceTaskContext(DbContextOptions <PanacheSoftwareServiceTaskContext> options, IUserProvider userProvider) : base(options)
{
_userProvider = userProvider;
}
public UserService(IUserProvider userProvider)
{
_userProvider = userProvider;
}
public RoutingEntryLookupFactory(IDatabaseLocationProvider databaseLocationProvider, IUserProvider userProvider)
{
if (databaseLocationProvider == null)
{
throw new ArgumentNullException("databaseLocationProvider");
}
if (userProvider == null)
{
throw new ArgumentNullException("userProvider");
}
this.databaseLocationProvider = databaseLocationProvider;
this.userProvider = userProvider;
}
public UsersController(ILogger <BaseAuthorizedController> logger, IUserProvider userProvider, MainContext context) : base(logger, userProvider)
{
_context = context;
}
public EmployeeServiceWrapper(IUserProvider userProvider)
{
this.userProvider = userProvider;
}
public Handler(IUnitOfWork unitOfWork, IUserProvider userProvider, IMapper mapper)
{
_unitOfWork = unitOfWork;
_userProvider = userProvider;
_mapper = mapper;
}
public ClearDataController(IUserProvider userProvider, IOTPProvider oTPProvider)
{
_userProvider = userProvider;
_OTPProvider = oTPProvider;
}
public UsersController(IUserProvider userProvider, IVisitProvider visitProvider)
{
_userProvider = userProvider;
_visitProvider = visitProvider;
}
public StatsController(INewsService <ApplicationRule> newsService, IMapperAdapter mapper, ISolutionLogger logger, IUserProvider userProvider)
: base(mapper, logger, userProvider)
{
if (newsService == null)
{
throw new NullReferenceException("INewsService not initialized");
}
_newsService = newsService;
}
public BasicAuthentication(IUserProvider userProvider)
{
_userProvider = userProvider;
}
public PanacheSoftwareUnitOfWork(DbContext context, IUserProvider userProvider)
{
_context = context;
_userProvider = userProvider;
}
public AddVehicleCommandHandler(IDealershipFactory dealershipFactory, IUserProvider userProvider)
{
this.dealershipFactory = dealershipFactory;
this.userProvider = userProvider;
}
public ItemController(AppDbContext db, IUserProvider provider)
{
this.db = db;
this.provider = provider;
}
public ShowVehicles(IUserProvider userProvider)
: base()
{
this.userProvider = userProvider;
}
public LoginController(IUserProvider userProvider, IRoleProvider roleProvider)
{
this.userProvider = userProvider;
this.roleProvider = roleProvider;
}
public TaskGroupController(IUnitOfWork unitOfWork, IMapper mapper, ITaskManager taskManager, IUserProvider userProvider, IAPIHelper apiHelper)
{
_unitOfWork = unitOfWork;
_mapper = mapper;
_taskManager = taskManager;
_userProvider = userProvider;
_apiHelper = apiHelper;
}
public AccountController(IMapperAdapter mapper, ISolutionLogger logger, IUserProvider userProvider)
: base(mapper, logger, userProvider)
{
}
public LadderService(IUnitOfWork unitOfWork, IUserProvider userProvider, Domain.Services.ILadderService ladderService)
: base(unitOfWork, userProvider)
{
this.ladderService = ladderService;
}
public UserServiceWrapper(IUserProvider userProvider)
{
this.userProvider = userProvider;
}
/// <summary>
/// Creates a new controller instance.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="focusCategoryService">The focus category service.</param>
/// <param name="justificationObjectiveService">The justification objective service.</param>
/// <param name="authorizationHandler"></param>
/// <param name="resourceService"></param>
/// <param name="userProvider"></param>
public OfficesController(IOfficeService service, IFocusCategoryService focusCategoryService, IJustificationObjectiveService justificationObjectiveService, IResourceService resourceService, IResourceAuthorizationHandler authorizationHandler, IUserProvider userProvider)
{
Contract.Requires(service != null, "The office service must not be null.");
Contract.Requires(focusCategoryService != null, "The focus category service must not be null.");
Contract.Requires(justificationObjectiveService != null, "The justification service must not be null.");
Contract.Requires(resourceService != null, "The resource service must not be null.");
Contract.Requires(authorizationHandler != null, "The authorization handler must not be null.");
Contract.Requires(userProvider != null, "The authorization handler must not be null.");
this.service = service;
this.focusCategoryService = focusCategoryService;
this.justificationObjectiveService = justificationObjectiveService;
this.resourceService = resourceService;
this.authorizationHandler = authorizationHandler;
this.userProvider = userProvider;
}
public DebugController(IServiceProvider serviceProvider,
IUserProvider userProvider,
IHostingEnvironment hostingEnvironment) : base(serviceProvider, userProvider)
{
this.hostingEnvironment = hostingEnvironment;
}
public UserController(AppDbContext db, IUserProvider identity)
{
this.db = db;
this.identity = identity;
}
public UserIndexViewModel(IUserProvider provider)
{
this.provider = provider;
LoadList();
}
public JobIndexServiceWrapper(IUserProvider userProvider)
{
this.userProvider = userProvider;
}
public NotificationService(IUnitOfWork unitOfWork, IUserProvider userProvider)
: base(unitOfWork, userProvider)
{
}
public RegisterUserCommandHandler(IUserProvider userProvider, IDealershipFactory dealershipFactory)
{
this.userProvider = userProvider;
this.dealershipFactory = dealershipFactory;
}
public UserService(IUnitOfWork unitOfWork, IUserProvider userProvider, Domain.Services.IUserService userService)
: base(unitOfWork, userProvider)
{
this.userService = userService;
}
public RecordController(IAnalyticsSettings analyticsSettings, IContentManager contentManager, IRepository <AnalyticsEntry> repository, IUserProvider userProvider)
{
_analyticsSettings = analyticsSettings;
_contentManager = contentManager;
_repository = repository;
_userProvider = userProvider;
}
public UserController(IUserProvider userProvider)
{
_userProvider = userProvider;
}
public Worker(ILogger <Worker> logger, IUserProvider userProvider, IUnitOfWork unitOfWork)
{
this.logger = logger;
scheduler = new Scheduler(userProvider, unitOfWork);
}
public NotificationHub(INotificationRepository notificationRepository, IUserProvider userProvider)
{
_notificationRepository = notificationRepository;
_userProvider = userProvider;
}
public BookController(IBooksService booksService, IRatingsService ratingsService, IMapperAdapter mapper, IUserProvider userProvider)
{
if (booksService == null)
{
throw new ArgumentNullException("booksService");
}
if (ratingsService == null)
{
throw new ArgumentNullException("ratingsService");
}
if (mapper == null)
{
throw new ArgumentNullException("mapper");
}
if (userProvider == null)
{
throw new ArgumentNullException("userProvider");
}
this.booksService = booksService;
this.ratingsService = ratingsService;
this.mapper = mapper;
this.userProvider = userProvider;
}
public AccountController(IUserProvider userProvider)
{
_userProvider = userProvider;
}
public UserController(IUserProvider user)
{
_user = user;
}