public AdminController(
IContentManager contentManager,
IContentItemDisplayManager contentItemDisplayManager,
IContentDefinitionManager contentDefinitionManager,
ISiteService siteService,
INotifier notifier,
ISession session,
IShapeFactory shapeFactory,
ILogger<AdminController> logger,
IHtmlLocalizer<AdminController> localizer,
IAuthorizationService authorizationService,
IEnumerable<IContentAdminFilter> contentAdminFilters
)
{
_contentAdminFilters = contentAdminFilters;
_authorizationService = authorizationService;
_notifier = notifier;
_contentItemDisplayManager = contentItemDisplayManager;
_session = session;
_siteService = siteService;
_contentManager = contentManager;
_contentDefinitionManager = contentDefinitionManager;
T = localizer;
New = shapeFactory;
Logger = logger;
}
public AccountController(IUserService userService, IAuthorizationService authService, IAnswerService answerService, ITaskService taskService)
{
this.userService = userService;
this.authService = authService;
this.answerService = answerService;
this.taskService = taskService;
}
public AdminMenu(IAuthorizationService authorizationService, IWorkContextAccessor workContextAccessor
, IOrchardServices orchardServices)
{
_authorizationService = authorizationService;
_workContextAccessor = workContextAccessor;
_orchardServices = orchardServices;
}
public UserTasksSelectorViewModel(
[Import]IBackgroundExecutor executor,
[Import]IEventAggregator aggregator,
[Import]ITasksService tasksService,
[Import] IDialogService dialogs,
[Import]IAuthorizationService authorizator)
{
this.executor = executor;
this.aggregator = aggregator;
this.tasksService = tasksService;
this.dialogs = dialogs;
this.authorizator = authorizator;
tasksViewSource = new System.Windows.Data.CollectionViewSource();
notMineTasksViewSource = new System.Windows.Data.CollectionViewSource();
TrackingTaskInfo = null;
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, m => { OnPropertyChanged("SignedMemberUId"); });
aggregator.Subscribe(ScrumFactoryEvent.ApplicationWhentForeground, () => { LoadTasks(true); });
aggregator.Subscribe(ScrumFactoryEvent.ShowUserTasksSelector, Show);
aggregator.Subscribe<Task>(ScrumFactoryEvent.TaskAssigneeChanged, OnTaskChanged);
aggregator.Subscribe<Task>(ScrumFactoryEvent.TaskChanged, OnTaskChanged);
ShowTaskDetailCommand = new DelegateCommand<TaskViewModel>(ShowTaskDetail);
TrackTaskCommand = new DelegateCommand<TaskViewModel>(TrackTask);
timeKeeper.Tick += new EventHandler(timeKeeper_Tick);
}
public SetupController(
IApplicationEnvironment appEnv,
ILogger<SetupController> logger,
IOptions<SetupOptions> setupOptionsAccessor,
SetupManager setupManager,
IAuthorizationService authorizationService,
IEnumerable<ISetupTask> setupSteps = null
)
{
if (appEnv == null) { throw new ArgumentNullException(nameof(appEnv)); }
if (logger == null) { throw new ArgumentNullException(nameof(logger)); }
if (setupOptionsAccessor == null) { throw new ArgumentNullException(nameof(setupOptionsAccessor)); }
if (setupManager == null) { throw new ArgumentNullException(nameof(setupManager)); }
if (authorizationService == null) { throw new ArgumentNullException(nameof(authorizationService)); }
log = logger;
appBasePath = appEnv.ApplicationBasePath;
this.setupManager = setupManager;
setupOptions = setupOptionsAccessor.Value;
this.authorizationService = authorizationService;
if(setupSteps != null)
{
this.setupSteps = setupSteps;
}
}
public DocumentSaver(IAuthorizationService authorizationService, AbstractValidator<Document> validator,
IDocumentRepository documentRepository)
{
_authorizationService = authorizationService;
_validator = validator;
_documentRepository = documentRepository;
}
public NavigationManager(IEnumerable<INavigationProvider> providers, IAuthorizationService authorizationService, UrlHelper urlHelper, IOrchardServices orchardServices) {
_providers = providers;
_authorizationService = authorizationService;
_urlHelper = urlHelper;
_orchardServices = orchardServices;
Logger = NullLogger.Instance;
}
public HomeController(
IAuthorizationService authorizationService,
IAlbumRepository albumRepository)
{
_authorizationService = authorizationService;
_albumRepository = albumRepository;
}
private void SetupEntities()
{
user = new User();
user.Name = "Ayende";
account = new Account();
account.Name = "south sand";
UnitOfWork.CurrentSession.Save(user);
UnitOfWork.CurrentSession.Save(account);
authorizationService = IoC.Resolve<IAuthorizationService>();
permissionService = IoC.Resolve<IPermissionsService>();
permissionsBuilderService = IoC.Resolve<IPermissionsBuilderService>();
authorizationRepository = IoC.Resolve<IAuthorizationRepository>();
authorizationRepository.CreateUsersGroup("Administrators");
authorizationRepository.CreateEntitiesGroup("Important Accounts");
authorizationRepository.CreateOperation("/Account/Edit");
UnitOfWork.Current.TransactionalFlush();
authorizationRepository.AssociateUserWith(user, "Administrators");
authorizationRepository.AssociateEntityWith(account, "Important Accounts");
UnitOfWork.Current.TransactionalFlush();
}
public OwnersListViewModel(
[Import]IEventAggregator eventAggregator,
[Import]ITeamService teamServices,
[Import]IBackgroundExecutor backgroundExecutor,
[Import] IDialogService dialogs,
[Import]IAuthorizationService authorizationService)
{
this.aggregator = eventAggregator;
this.teamServices = teamServices;
this.executor = backgroundExecutor;
this.authorizator = authorizationService;
this.dialogs = dialogs;
aggregator.Subscribe(ScrumFactoryEvent.ShowOwnersList, Show);
CloseWindowCommand = new DelegateCommand(CloseWindow);
OnLoadCommand = new DelegateCommand(LoadOwners);
ChangeFactoryOwnerCommand = new DelegateCommand<string>(ChangeFactoryOwner);
ChangeCanSeeProposalsCommand = new DelegateCommand<string>(ChangeCanSeeProposals);
AddNewMemberCommand = new DelegateCommand(AddNewMember);
RefreshMemberFilter = LoadMembers;
}
public ReportPostAdminController(
IOrchardServices orchardServices,
IForumService forumService,
IThreadService threadService,
IPostService postService,
ISiteService siteService,
IShapeFactory shapeFactory,
IAuthorizationService authorizationService,
IAuthenticationService authenticationService,
ISubscriptionService subscriptionService,
IReportPostService reportPostService,
ICountersService countersService
)
{
_orchardServices = orchardServices;
_forumService = forumService;
_threadService = threadService;
_postService = postService;
_siteService = siteService;
_subscriptionService = subscriptionService;
_authorizationService = authorizationService;
_authenticationService = authenticationService;
_reportPostService = reportPostService;
_countersService = countersService;
T = NullLocalizer.Instance;
Shape = shapeFactory;
}
public ProposalsListViewModel(
[Import]IBackgroundExecutor executor,
[Import]IEventAggregator eventAggregator,
[Import]IDialogService dialogs,
[Import]IAuthorizationService authorizator,
[Import]IBacklogService backlogService,
[Import]IProposalsService proposalsService)
{
this.executor = executor;
this.dialogs = dialogs;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
this.proposalsService = proposalsService;
this.backlogService = backlogService;
this.aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
this.aggregator.Subscribe(ScrumFactoryEvent.RoleHourCostsChanged, LoadProposals);
this.aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);
this.aggregator.Subscribe(ScrumFactoryEvent.ApplicationWhentBackground, () => { ShowValues = false; });
OnLoadCommand = new DelegateCommand(CanSeeProposals, () => {
ShowValues = false;
if (NeedRefresh) LoadProposals();
});
AddProposalCommand = new DelegateCommand(CanSeeProposals, AddProposal);
ShowDetailCommand = new DelegateCommand<Proposal>(CanSeeProposals, ShowDetail);
ShowHourCostsCommand = new DelegateCommand(CanSeeProposals, ShowHourCosts);
}
/// <summary>
/// Initializes a new instance of the <see cref="SimBalanceViewModel" /> class.
/// </summary>
/// <param name="simBalance">The sim balance.</param>
/// <param name="topUpHistory">The top up history.</param>
/// <param name="usageHistory">The usage history.</param>
/// <param name="authorizationService">The authorization service.</param>
/// <param name="navigationService">The navigation service.</param>
/// <param name="resourceLoader">The resource loader.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public SimBalanceViewModel(ISimBalance simBalance, ITopUpHistory topUpHistory, IUsageHistory usageHistory, IAuthorizationService authorizationService, INavigationService navigationService, ResourceLoader resourceLoader)
: base(authorizationService, resourceLoader, navigationService)
{
if (simBalance == null)
{
throw new ArgumentNullException("simBalance");
}
if (topUpHistory == null)
{
throw new ArgumentNullException("topUpHistory");
}
if (usageHistory == null)
{
throw new ArgumentNullException("usageHistory");
}
_mobileNumber = (DTO.MobileNumber)NavigationService.Parameter;
_simBalanceRepository = simBalance;
_topUpHistory = topUpHistory;
_usageHistory = usageHistory;
Groups = new ObservableCollection<Group>();
HandleNoInternet();
LoadBalance();
}
/// <param name="authorizationService">Service that authorizes each method for use if configured</param>
/// <param name="policyProvider">Provides authorization policies for the authroziation service</param>
/// <param name="logger">Optional logger for logging Rpc invocation</param>
/// <param name="serverConfig">Configuration data for the server</param>
public DefaultRpcInvoker(IAuthorizationService authorizationService, IAuthorizationPolicyProvider policyProvider, ILogger<DefaultRpcInvoker> logger, IOptions<RpcServerConfiguration> serverConfig)
{
this.authorizationService = authorizationService;
this.policyProvider = policyProvider;
this.logger = logger;
this.serverConfig = serverConfig;
}
public WikiPageController(IOrchardServices orchardServices,
IRepository<WikiPageAttachmentRecord> repoWikiAttachment,
ITagService tagService,
IAuthorizationService authorizationService,
INotifier notifier,
ISiteService siteService,
ISearchService searchService,
IShapeFactory shapeFactory,
IWikiPageService wikiPageService,
IMediaService mediaService
){
_orchardServices = orchardServices;
_repoWikiAttachment = repoWikiAttachment;
_tagService = tagService;
_authorizationService = authorizationService;
_notifier = notifier;
_searchService = searchService;
_siteService = siteService;
_wikiPageService = wikiPageService;
_mediaService = mediaService;
Logger = NullLogger.Instance;
Shape = shapeFactory;
}
public MemberViewModel(
[Import(typeof(IAuthorizationService))] IAuthorizationService authorizator,
[Import(typeof(IBackgroundExecutor))] IBackgroundExecutor executor,
[Import(typeof(IEventAggregator))] IEventAggregator aggregator,
[Import] IDialogService dialogs,
[Import(typeof(ITasksService))] ITasksService taskService,
[Import(typeof(ITeamService))] ITeamService teamService)
{
this.taskService = taskService;
this.authorizator = authorizator;
this.executor = executor;
this.aggregator = aggregator;
this.teamService = teamService;
this.dialogs = dialogs;
aggregator.Subscribe(ScrumFactoryEvent.ShowProfile, Show);
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);
ChangeAvatarCommand = new DelegateCommand(ChangeMemberImage);
RemoveAvatarCommand = new DelegateCommand(RemoveMemberImage);
CloseWindowCommand = new DelegateCommand(Close);
CreateAvatarCommand = new DelegateCommand(CreateAvatar);
UpdateAvatarCommand = new DelegateCommand(() => {
executor.StartBackgroundTask(
() => {
teamService.UpdateMember(authorizator.SignedMemberProfile.MemberUId, MemberProfile);
}, () => {
myProfileNocache = new Random().Next().ToString();
DefineMemberAvatarUrl();
});
});
}
public BurndownViewModel(
[Import] IBacklogService backlogService,
[Import] IProjectsService projectsService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator,
[Import] IAuthorizationService authorizator)
{
this.backlogService = backlogService;
this.projectsService = projectsService;
this.executor = backgroundExecutor;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
NeedRefresh = false;
OnLoadCommand = new DelegateCommand(() => {if (NeedRefresh) LoadData();});
SetBaselineCommand = new DelegateCommand(_CanChangeBaseline, SetBaseline);
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, p=> {
Project = p;
SetPlannings();
AskForRefresh();
});
aggregator.Subscribe<Project>(ScrumFactoryEvent.BurndownShouldRefresh, AskForRefresh);
aggregator.Subscribe<ICollection<Sprint>>(ScrumFactoryEvent.SprintsDateChanged, o => { AskForRefresh(); });
aggregator.Subscribe<BacklogItem[]>(ScrumFactoryEvent.BacklogItemsChanged, b => { AskForRefresh(); });
}
/// <summary>
/// Session controller constructor.
/// </summary>
/// <param name="sessionRepository">The session repository.</param>
/// <param name="materialRepository">The material repository.</param>
/// <param name="eventsRepository">The events repository.</param>
/// <param name="authorizationService">The authorization service.</param>
public SessionController(ISessionRepository sessionRepository, IMaterialRepository materialRepository, IEventDefinitionRepository eventsRepository, IAuthorizationService authorizationService)
{
_sessionRepository = sessionRepository;
_materialRepository = materialRepository;
_eventsRepository = eventsRepository;
_authorizationService = authorizationService;
}
public AdminController(
IAuthorizationService authorizationService,
ITypeFeatureProvider typeFeatureProvider,
ISession session,
IStringLocalizer<AdminController> stringLocalizer,
IHtmlLocalizer<AdminController> htmlLocalizer,
ISiteService siteService,
IShapeFactory shapeFactory,
RoleManager<Role> roleManager,
IRoleProvider roleProvider,
INotifier notifier,
IEnumerable<IPermissionProvider> permissionProviders
)
{
TH = htmlLocalizer;
_notifier = notifier;
_roleProvider = roleProvider;
_typeFeatureProvider = typeFeatureProvider;
_permissionProviders = permissionProviders;
_roleManager = roleManager;
_shapeFactory = shapeFactory;
_siteService = siteService;
T = stringLocalizer;
_authorizationService = authorizationService;
_session = session;
}
public async Task Invoke(HttpContext context, IAuthorizationService authorizationService) {
if(context.Request.Path.StartsWithSegments(_path)) {
if(await authorizationService.AuthorizeAsync(context.User, null, _policy)) {
await _next(context);
}
}
}
public Services(IResourceCatalog resourceCatalog, IAuthorizationService authorizationService)
{
VerifyArgument.IsNotNull("resourceCatalog", resourceCatalog);
VerifyArgument.IsNotNull("authorizationService", authorizationService);
_resourceCatalog = resourceCatalog;
_authorizationService = authorizationService;
}
public ApiController(
IContentManager contentManager,
IAuthorizationService authorizationService)
{
_authorizationService = authorizationService;
_contentManager = contentManager;
}
protected override void Context()
{
MockAuthorizationService = MockRepository.GenerateStub<IAuthorizationService>();
MockDocumentRepository = MockRepository.GenerateStub<IDocumentRepository>();
MockCustomerRepository = MockRepository.GenerateStub<ICustomerRepository>();
//DocumentService = new DocumentService(MockAuthorizationService, MockDocumentRepository, MockCustomerRepository);
}
private void RemoveActionImplementation(IAuthorizationService authService, MethodInfo method)
{
foreach (CommandHandlerAttribute attr in method.GetCustomAttributes(typeof(CommandHandlerAttribute), true))
{
//authService.UnRegisterCommand(attr.CommandName, GetAuthorizeResourcePath(method));
}
}
public Authorizer(IAuthorizationService authorizationService, IWorkContextAccessor workContextAccessor)
{
_authorizationService = authorizationService;
_workContextAccessor = workContextAccessor;
T = NullLocalizer.Instance;
}
public AdminController(
IContentDefinitionDisplayManager contentDefinitionDisplayManager,
IContentDefinitionService contentDefinitionService,
IContentDefinitionManager contentDefinitionManager,
ShellSettings settings,
IAuthorizationService authorizationService,
ISession session,
ILogger<AdminController> logger,
IHtmlLocalizer<AdminMenu> htmlLocalizer,
IStringLocalizer<AdminMenu> stringLocalizer,
INotifier notifier
)
{
_notifier = notifier;
_contentDefinitionDisplayManager = contentDefinitionDisplayManager;
_session = session;
_authorizationService = authorizationService;
_contentDefinitionService = contentDefinitionService;
_contentDefinitionManager = contentDefinitionManager;
_settings = settings;
Logger = logger;
T = htmlLocalizer;
S = stringLocalizer;
}
public SubscriptionController(
IOrchardServices orchardServices,
IForumService forumService,
IThreadService threadService,
IPostService postService,
ISiteService siteService,
IShapeFactory shapeFactory,
IAuthorizationService authorizationService,
IAuthenticationService authenticationService,
ISubscriptionService subscriptionService,
IThreadLastReadService threadLastReadService
)
{
_orchardServices = orchardServices;
_forumService = forumService;
_threadService = threadService;
_postService = postService;
_siteService = siteService;
_subscriptionService = subscriptionService;
_authorizationService = authorizationService;
_authenticationService = authenticationService;
_threadLastReadService = threadLastReadService;
T = NullLocalizer.Instance;
Shape = shapeFactory;
}
public SizeListViewModel(
[Import] IBacklogService backlogService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator,
[Import] IDialogService dialogs,
[Import] IAuthorizationService authorizator)
{
this.backlogService = backlogService;
this.executor = backgroundExecutor;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
this.dialogs = dialogs;
AddNewSizeCommand = new DelegateCommand(CanEditItemSizes, AddNewSize);
CloseWindowCommand = new DelegateCommand(CloseWindow);
DeleteSizeCommand = new DelegateCommand<SizeViewModel>(CanEditItemSizes, DeleteSize);
SetAsPlanningItemCommand = new DelegateCommand<SizeViewModel>(CanEditItemSizes, size => SetItemOccurrenceContraint(size, ItemOccurrenceContraints.PLANNING_OCC));
SetAsDeliveryItemCommand = new DelegateCommand<SizeViewModel>(CanEditItemSizes, size => SetItemOccurrenceContraint(size, ItemOccurrenceContraints.DELIVERY_OCC));
sizesViewSource = new System.Windows.Data.CollectionViewSource();
sizesViewSource.Filter += new System.Windows.Data.FilterEventHandler(sizesViewSource_Filter);
delayFilter = new DelayAction(1200, new DelayAction.ActionDelegate(() => { FilteredSizes.Refresh(); }));
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged,
m => {
RefreshCommands();
if (m == null) return;
if (Sizes!=null) return;
LoadItemSizes();
});
}
public AdminUserController(IUserService userService,
IRoleService roleService,
IAuthorizationService authorizationService)
{
_userService = userService;
_roleService = roleService;
_authorizationService = authorizationService;
}
public AlbumsController(IAuthorizationService authorizationService,
IAlbumRepository albumRepository,
ILoggingRepository loggingRepository)
{
_authorizationService = authorizationService;
_albumRepository = albumRepository;
_loggingRepository = loggingRepository;
}
public AuthorizationPolicyTagHelper(IHttpContextAccessor httpContextAccessor, IAuthorizationService authorizationService)
{
_httpContextAccessor = httpContextAccessor;
_authorizationService = authorizationService;
}
public Handler(CasterContext db, IMapper mapper, IAuthorizationService authorizationService, IIdentityResolver identityResolver) : base(db, mapper)
{
_authorizationService = authorizationService;
_user = identityResolver.GetClaimsPrincipal();
}
public static bool CanExecuteCurrentResource(this IDSFDataObject dataObject, IResource resource, IAuthorizationService service)
{
var canExecute = true;
if (service != null && dataObject.ReturnType != EmitionTypes.TEST)
{
var hasView = service.IsAuthorized(AuthorizationContext.View, dataObject.ResourceID.ToString());
var hasExecute = service.IsAuthorized(AuthorizationContext.Execute, dataObject.ResourceID.ToString());
canExecute = (hasExecute && hasView) || ((dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) && hasExecute) || (resource != null && resource.ResourceType == "ReservedService");
}
return(canExecute);
}
public RestaurantService(RestaurantDbContext dbContext, IMapper mapper, ILogger <RestaurantService> logger, IAuthorizationService authorizationService, IUserContextService userContextService)
{
_dbContext = dbContext;
_mapper = mapper;
_logger = logger;
_authorizationService = authorizationService;
_userContextService = userContextService;
}
public LogsController(IAuthorizationService authorizationService, CTDbContext context, UserUtils userUtils, ILogger <LogsController> logger) : base(context, logger)
{
_authorizationService = authorizationService;
_userUtils = userUtils;
}
public UsersController(IUserService userService, IAuthorizationService authorizationService)
{
this._userService = userService;
this._authorizationService = authorizationService;
}
public CreateModel(FreelanceDir.Data.RDSContext context, UserManager <User> userManager, IAuthorizationService authorizationService)
{
_context = context;
_userManager = userManager;
_authorizationService = authorizationService;
}
public ProjetController(IProjetRepository projetRepository, IAutorisationRepository autorisationRepository, INotificationRepository notificationRepository, IMapper mapper, IAuthorizationService authorizationService)
{
_projetRepository = projetRepository;
_autorisationRepository = autorisationRepository;
_notificationRepository = notificationRepository;
_authorizationService = authorizationService;
_mapper = mapper;
}
public Executor(IWorkspaceRepository workspaceRepository, IResourceCatalog resourceCatalog, ITestCatalog testCatalog, ITestCoverageCatalog testCoverageCatalog, IServiceTestExecutor serviceTestExecutor, IAuthorizationService authorizationService, IDataObjectFactory dataObjectFactory, IEsbChannelFactory esbChannelFactory, IJwtManager jwtManager)
: base(workspaceRepository, resourceCatalog, testCatalog, testCoverageCatalog, serviceTestExecutor, authorizationService, dataObjectFactory, esbChannelFactory, jwtManager)
{
}
public WebServices(IResourceCatalog resourceCatalog, WebExecuteString webExecute, IAuthorizationService authorizationService)
: base(resourceCatalog, authorizationService)
{
VerifyArgument.IsNotNull("webExecute", webExecute);
_webExecute = webExecute;
}
public GuildStatsController(IGuildStatService statService, DiscordSocketClient client, IAuthorizationService modixAuth) : base(client, modixAuth)
{
_statService = statService;
}
public MeetupController(MeetupContext meetupContext, IMapper mapper, IAuthorizationService authorizationService)
{
_meetupContext = meetupContext;
_mapper = mapper;
_authorizationService = authorizationService;
}
public LoginDialogViewModel(ILogger logger, IAuthorizationService authorizationService, ICredentialService credentialService) : base(logger)
{
_authorizationService = authorizationService;
_credentialService = credentialService;
}
public SlursCommands(ISlurRepository slursRepository, IUserRepository userRepository, ISlackWebApi messageSender, IAuthorizationService adminValidator, IEventDispatcher eventDispatcher, IUserService userService, ICreditsRepository creditsRepository)
{
_slurRepository = slursRepository;
_userRepository = userRepository;
_slack = messageSender;
_adminValidator = adminValidator;
_eventDispatcher = eventDispatcher;
_userService = userService;
_creditsRepository = creditsRepository;
}
public DetailModel(IRecipeService recipeService, IAuthorizationService authorizationService)
{
this._recipeService = recipeService;
this._authorizationService = authorizationService;
}
public UserService(ILogger <UserService> logger, IUserRepository users, IAuthorizationService authorization)
{
_logger = logger;
_users = users;
_authorization = authorization;
}
public MealsController(IMealService mealService,
IAuthorizationService authorizationService)
{
_mealService = mealService;
_authorizationService = authorizationService;
}
public AdminFilter(IAuthorizationService authorizationService)
{
_authorizationService = authorizationService;
}
public AdvertistmentController(IAdvertistmentService advertistmentService, IHostingEnvironment env, IAuthorizationService authorizationService)
{
_advertistmentService = advertistmentService;
_env = env;
_authorizationService = authorizationService;
}
public RoleController(DiscordSocketClient client, IAuthorizationService modixAuth, IDesignatedRoleService roleService) : base(client, modixAuth)
{
RoleService = roleService;
}
public ContextualEditPartDisplay(IAuthorizationService authorizationService, IContextualEditService contextualEditService, IHttpContextAccessor httpContextAccessor)
{
_authorizationService = authorizationService;
_contextualEditService = contextualEditService;
_httpContextAccessor = httpContextAccessor;
}
public EditModel(IPostAppService postAppService, IBlogAppService blogAppService, IAuthorizationService authorization)
{
_postAppService = postAppService;
_blogAppService = blogAppService;
_authorization = authorization;
}
public IndexModel(NodeContext context,
IAuthorizationService authorizationService,
UserManager <TradeControlWebUser> userManager)
: base(context, authorizationService, userManager)
{
}
public ProductController(IRepository repo, IAuthorizationService auth)
{
_repo = repo;
_auth = auth;
}
public ReservationController(UserManager <ApplicationUser> userManager, ApplicationDbContext context, IAuthorizationService authorizationService)
{
_userManager = userManager;
_context = context;
_authorizationService = authorizationService;
}
public BacklogTaskSchedulesController(ScrumContext context, IAuthorizationService authorizationService)
{
_context = context;
_authorizationService = authorizationService;
}
public PhotosService(IPhotosRepository repository, IAuthorizationService <Photo> photosAuthorizationService, IUserService userService)
{
this.repository = repository;
this.photosAuthorizationService = photosAuthorizationService;
this.userService = userService;
}
public SlideController(ISlideService slideService, IAuthorizationService authorizationService, SignInManager <AppUser> signInManager)
{
_slideService = slideService;
this._authorizationService = authorizationService;
this._signInManager = signInManager;
}
public NotificationsMessageHandler(INotificationsDataProvider notificationsDataProvider, IAuthorizationService authService, WebSocketConnectionManager webSocketConnectionManager)
: base(webSocketConnectionManager)
{
_notificationsDataProvider = notificationsDataProvider;
_authService = authService;
}
public DataAccessUserContext(ApplicationUser UserIdentity, ClaimsPrincipal UserPrincipal, IAuthorizationService Auth)
{
this.UserIdentity = UserIdentity;
this.UserPrincipal = UserPrincipal;
this.Auth = Auth;
}
