public SaveSettingsCommand(SettingsViewModel viewModel, ISettingsRepositories repos, IUserNotify notify, ISecurityContext ctx)
 {
     this.viewModel = viewModel;
     this.repos = repos;
     this.notify = notify;
     this.ctx = ctx;
 }

 public SaveReleaseNoteCommand(ReleaseNoteViewModel viewModel, IReleaseNoteRepositories repo, IUserNotify notify, ISecurityContext ctx)
 {
     this.viewModel = viewModel;
     this.repos = repo;
     this.notify = notify;
     this.ctx = ctx;
 }

        public PartInspectionViewModel(ISession session, IPartInspectionRepository repos, IUserNotify notify, ISecurityContext ctx)
        {
            try
            {
                this.session = session;
                this.repos = repos;
                this.notify = notify;
                this.ctx = ctx;

                this.Inspectors = repos.RepoInspector.GetAll();
                if(this.Inspectors == null || this.Inspectors.Count <= 0)
                    log.Warn("Incoming Inspection of Componentry: List of Inspectors is NULL or empty");

                searchCommand = ViewModelSource.Create(() => new SearchPartForInspectionCommand(this, session, ctx));
                saveInspectionTestResultsCommand = ViewModelSource.Create(() => new SaveInspectionTestResultsCommand(repos.RepoInspectionTestResult, this, notify, ctx));
                saveAndClearTestResultsCommand = ViewModelSource.Create(() => new SaveAndClearTestResultsCommand(this));
                this.Inspectors = repos.RepoInspector.GetAll();
            }
            catch(RepositoryException ex)
            {
                log.Warn(this.GetType().Name + " | " + ex.ToString());
                notify.ShowWarning(Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Message),
            Program.LanguageManager.GetString(StringResources.Notification_Error_Db_Header));
            }
        }

        public SecurityContextWrapper(ISecurityContext securityContext)
        {
            if (securityContext == null)
                throw new ArgumentNullException("securityContext");

            _securityContext = securityContext;
        }

        public IEnumerable<PolicyResult> EnforcePolicies(ISecurityContext context)
        {
            if (_policies.Count.Equals(0))
                throw ExceptionFactory.CreateConfigurationErrorsException("You must add at least 1 policy for controller {0} action {1}.".FormatWith(ControllerName, ActionName));

            return _policies.Select(policy => policy.Enforce(context)).ToArray();
        }

 public AuthenticationContextService(ISecurityContext securityContext, IPrincipalFactory principalFactory, ICurrentSDKUser currentSdkUser, ILogger logger)
 {
     _securityContext = securityContext;
     _principalFactory = principalFactory;
     _currentSdkUser = currentSdkUser;
     _logger = logger;
 }

 public AuthenticationRequiredBehavior(ISecurityContext securityContext, IUrlRegistry urlRegistry, IOutputWriter outputWriter)
     : base(PartialBehavior.Ignored)
 {
     _securityContext = securityContext;
     _urlRegistry = urlRegistry;
     _outputWriter = outputWriter;
 }

 public SaveInspectionTestResultsCommand(IInspectionTestResultRepository repo, PartInspectionViewModel viewModel, IUserNotify notify, ISecurityContext ctx)
 {
     this.repo = repo;
     this.viewModel = viewModel;
     this.notify = notify;
     this.ctx = ctx;
 }

 public SpoolDeactivationCommand(ISpoolRepositories repo, SpoolViewModel viewModel, IUserNotify notify, ISecurityContext ctx)
 {
     this.repo = repo;
     this.viewModel = viewModel;
     this.notify = notify;
     this.ctx = ctx;
 }

        public AddAction(IDailyTimeRecordService timeRecordService,  IUserService userService, ISecurityContext securityContext)
        {
            _timeRecordService = timeRecordService;

            _userService = userService;
            _securityContext = securityContext;
        }

		public StatusPointsService(IAppraiserOrderDeliveryService appraiserOrderDeliveryService, DashboardConditionFilters dashboardConditionFilters, ICurrentAppraiser currentAppraiser, ISecurityContext securityContext)
		{
			_securityContext = ValidationUtil.CheckOnNullAndThrowIfNull(securityContext);
			_appraiserOrderDeliveryService = ValidationUtil.CheckOnNullAndThrowIfNull(appraiserOrderDeliveryService);
			_dashboardConditionFilters = ValidationUtil.CheckOnNullAndThrowIfNull(dashboardConditionFilters);
			_currentAppraiser = ValidationUtil.CheckOnNullAndThrowIfNull(currentAppraiser);
		}

 internal PolicyViolationException(PolicyResult policyResult, ISecurityContext securityContext)
     : base(policyResult.Message)
 {
     PolicyResult = policyResult;
     SecurityContext = securityContext;
     PolicyType = PolicyResult.PolicyType;
 }

        public SpiderFactory(ILogger logger, ISecurityContext securityContext, IMediaFactory mediaFactory, ILinkRepository linkRepository, ITagRepository tagRepository, IMediaRepository mediaRepository, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory)
        {
            if (logger == null)
                throw new ArgumentNullException("logger");
            if (securityContext == null)
                throw new ArgumentNullException("securityContext");
            if (mediaFactory == null)
                throw new ArgumentNullException("mediaFactory");
            if (linkRepository == null)
                throw new ArgumentNullException("linkRepository");
            if (tagRepository == null)
                throw new ArgumentNullException("tagRepository");
            if (mediaRepository == null)
                throw new ArgumentNullException("mediaRepository");
            if (mediaItemRepository == null)
                throw new ArgumentNullException("mediaItemRepository");

            this.logger = logger;
            this.securityContext = securityContext;
            this.securityContext = securityContext;
            this.mediaFactory = mediaFactory;
            this.linkRepository = linkRepository;
            this.tagRepository = tagRepository;
            this.mediaRepository = mediaRepository;
            this.mediaItemRepository = mediaItemRepository;
            this.audioStreamFactory = audioStreamFactory;
        }

        public void Initialize(ILogger logger, ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataController mediaItemController, ITaskController taskController, ITagController tagController, IVideoPlayer videoPlayer)
        {
            if (logger == null)
                throw new ArgumentNullException("logger");
            if (securityContext == null)
                throw new ArgumentNullException("securityContext");
            if (mediaFactory == null)
                throw new ArgumentNullException("mediaFactory");
            if (mediaItemController == null)
                throw new ArgumentNullException("mediaItemController");
            if (taskController == null)
                throw new ArgumentNullException("taskController");
            if (tagController == null)
                throw new ArgumentNullException("tagController");
            if (videoPlayer == null)
                throw new ArgumentNullException("videoPlayer");

            this.logger = logger;
            this.securityContext = securityContext;
            this.mediaFactory = mediaFactory;
            this.taskController = taskController;
            this.mediaItemController = mediaItemController;
            this.tagController = tagController;
            this.videoPlayer = videoPlayer;
        }

        public PolicyResult Enforce(ISecurityContext context)
        {
            var innerPolicy = new RequireAllRolesPolicy(UserRole.Administrator);
            var result = innerPolicy.Enforce(context);

            return result.ViolationOccured ? PolicyResult.CreateFailureResult(this, result.Message) : PolicyResult.CreateSuccessResult(this);
        }

 public JointDeactivationCommand(IConstructionRepository repo, JointNewEditViewModel viewModel, IUserNotify notify, ISecurityContext ctx)
 {
     this.repo = repo;
     this.viewModel = viewModel;
     this.notify = notify;
     this.ctx = ctx;
 }

 public QuizTakeEndpoint(IQuizService quizService, IQuizTakeFactory quizTakeFactory, ISecurityContext securityContext, IQuizTakeService quizTakeService)
 {
     _quizService = quizService;
     _quizTakeFactory = quizTakeFactory;
     _securityContext = securityContext;
     _quizTakeService = quizTakeService;
 }

        public ActionResult HandleSecurityFor(string controllerName, string actionName, ISecurityContext securityContext)
        {
            if (controllerName.IsNullOrEmpty()) throw new ArgumentException("Controllername must not be null or empty", "controllerName");
            if (actionName.IsNullOrEmpty()) throw new ArgumentException("Actionname must not be null or empty", "actionName");
            if (securityContext == null) throw new ArgumentNullException("securityContext", "Security context must not be null");

            var configuration = ServiceLocator.Current.Resolve<ISecurityConfiguration>();

            var policyContainer = configuration.PolicyContainers.GetContainerFor(controllerName, actionName);
            if (policyContainer != null)
            {
                var results = policyContainer.EnforcePolicies(securityContext);
                if (results.Any(x => x.ViolationOccured))
                {
                    var result = results.First(x => x.ViolationOccured);
                    var policyViolationException = new PolicyViolationException(result);
                    var violationHandlerSelector = ServiceLocator.Current.Resolve<IPolicyViolationHandlerSelector>();
                    var matchingHandler = violationHandlerSelector.FindHandlerFor(policyViolationException) ?? new ExceptionPolicyViolationHandler();
                    return matchingHandler.Handle(policyViolationException);
                }
                return null;
            }

            if (configuration.IgnoreMissingConfiguration)
                return null;

            throw ExceptionFactory.CreateConfigurationErrorsException("Security has not been configured for controller {0}, action {1}".FormatWith(controllerName, actionName));
        }

 public SecurityApplicationProcessingRule(ISecurityAuthorizationProvider securityAuthorizationProvider, IGenericRepository genericRepository, ISecurityContext securityContext, IObjectFactory objectFactory)
 {
     _securityAuthorizationProvider = securityAuthorizationProvider;
     _genericRepository = genericRepository;
     _securityContext = securityContext;
     _objectFactory = objectFactory;
 }

 public EditPipeForCutCommand(SpoolViewModel viewModel, ISpoolRepositories repos, IUserNotify notify, ISecurityContext ctx)
 {
     this.viewModel = viewModel;
     this.repos = repos;
     this.notify = notify;
     this.ctx = ctx;
 }