public DropboxHandler(ITracer tracer, IServerRepository repository, IDeploymentSettingsManager settings, IEnvironment environment) { _tracer = tracer; _helper = new DropboxHelper(tracer, repository, settings, environment); }
public ProxyService(IHgServer hgServer, IServerConfiguration configuration, IDeploymentManager deploymentManager, IServerRepository severRepository) { _hgServer = hgServer; _configuration = configuration; _deploymentManager = deploymentManager; _severRepository = severRepository; }
public DropboxHelper(ITracer tracer, IServerRepository repository, IDeploymentSettingsManager settings, IEnvironment environment) { _tracer = tracer; _repository = repository; _settings = settings; _environment = environment; }
public DropboxHelper(ITracer tracer, IServerRepository repository, IDeploymentSettingsManager settings, IEnvironment environment) { _tracer = tracer; _repository = repository; _settings = settings; _environment = environment; _timeout = settings.GetCommandIdleTimeout(); }
public LiveScmController(ITracer tracer, IOperationLock deploymentLock, IEnvironment environment, IServerRepository repository, IServerConfiguration serverConfiguration) { _tracer = tracer; _deploymentLock = deploymentLock; _environment = environment; _repository = repository; _serverConfiguration = serverConfiguration; }
public DeploymentManager(IServerRepository serverRepository, ISiteBuilderFactory builderFactory, IEnvironment environment, IDeploymentSettingsManager settingsManager, IFileSystem fileSystem, IProfilerFactory profilerFactory) { _serverRepository = serverRepository; _builderFactory = builderFactory; _environment = environment; _settingsManager = settingsManager; _fileSystem = fileSystem; _profilerFactory = profilerFactory; }
public CommandHandler(DiscordSocketClient client, CommandService commands, ISettings settings, IServiceProvider serviceProvider, ILogger <CommandHandler> logger, IServerService servers, BannerImageService bannerImageService, IAutoRoleService autoRoleService, IProfanityRepository profanityRepository, IApiService apiService, IWelcomeMessageRepository welcomeMessageRepository, IPartMessageRepository partMessageRepository, IUserRepository userRepository, IInviteRepository inviteRepository, IServerInviteRepository serverInviteRepository, IServerRepository serverRepository) { _client = client; _commands = commands; _settings = settings; _serviceProvider = serviceProvider; _logger = logger; _servers = servers; _bannerImageService = bannerImageService; _autoRoleService = autoRoleService; _profanityRepository = profanityRepository; _apiService = apiService; _welcomeMessageRepository = welcomeMessageRepository; _partMessageRepository = partMessageRepository; _userRepository = userRepository; _inviteRepository = inviteRepository; _serverInviteRepository = serverInviteRepository; _serverRepository = serverRepository; _client.MessageReceived += OnMessageReceived; _client.UserJoined += OnUserJoined; _client.ReactionAdded += OnReactionAdded; _client.MessageUpdated += OnMessageUpated; _client.UserLeft += OnUserLeft; _client.JoinedGuild += OnJoinedGuild; _client.Ready += OnReady; _client.InviteCreated += OnInviteCreated; _commands.CommandExecuted += OnCommandExecuted; ProfanityHelper.ProfanityRepository = profanityRepository; Task.Run(async() => await MuteHandler.MuteWorker(client)); Task.Run(async() => await PomodoroHandler.PomodoroWorker(client)); }
private static IServerRepository GetEnvironmentRepository() { var models = new List <IServer> { _environmentModel.Object }; var mock = new Mock <IServerRepository>(); mock.Setup(s => s.All()).Returns(models); mock.Setup(s => s.IsLoaded).Returns(true); mock.Setup(repository => repository.Source).Returns(_environmentModel.Object); mock.Setup(repository => repository.FindSingle(It.IsAny <Expression <Func <IServer, bool> > >())).Returns(_environmentModel.Object); _serverRepo = mock.Object; return(_serverRepo); }
public UserService( MasterServerMessageDispatcher messageDispatcher, IRelayServerService relayServerService, IServerRepository serverRepository, IMasterServerSessionService sessionService, IServerCodeProvider serverCodeProvider) { _messageDispatcher = messageDispatcher; _relayServerService = relayServerService; _serverRepository = serverRepository; _sessionService = sessionService; _serverCodeProvider = serverCodeProvider; _logger = Log.ForContext <UserService>(); }
public InviteModule(IInviteRepository inviteRepository, ILogger <InviteModule> logger, IUserRepository userRepository, IServerRepository serverRepository, IServerService serverService, CommandHandler commandHandler) { _inviteRepository = inviteRepository; _logger = logger; _userRepository = userRepository; _serverRepository = serverRepository; _serverService = serverService; _commandHandler = commandHandler; }
public DeploymentManager(IServerRepository serverRepository, ISiteBuilderFactory builderFactory, IEnvironment environment, IFileSystem fileSystem, ITraceFactory traceFactory, IOperationLock deploymentLock) { _serverRepository = serverRepository; _builderFactory = builderFactory; _environment = environment; _fileSystem = fileSystem; _traceFactory = traceFactory; _deploymentLock = deploymentLock; }
public UserExperienceSampleService( IUserExperienceService userExperienceService, IHourRepository hourRepository, ILogger logger, IUserExperienceCacheRepository userExperienceCacheRepository, ISampleHistoryRepository sampleHistoryRepository, IServerRepository serverRepository) { this.userExperienceService = userExperienceService; this.hourRepository = hourRepository; this.logger = logger.WithClassName().WithCategory(Names.LogCategory.UserExperience); this.userExperienceCacheRepository = userExperienceCacheRepository; this.sampleHistoryRepository = sampleHistoryRepository; this.serverRepository = serverRepository; }
public HourCleanupLogic( IHourRepository hourRepository, IServerRepository serverRepository, ICleanupTablesRepository cleanupTablesRepository, IDataIntegrityRepository dataIntegrityRepository, IServerCleanupRepository serverCleanupRepository, ILogger logger) { this.hourRepository = hourRepository; this.serverRepository = serverRepository; this.cleanupTablesRepository = cleanupTablesRepository; this.dataIntegrityRepository = dataIntegrityRepository; this.serverCleanupRepository = serverCleanupRepository; this.logger = logger.WithClassName().WithCategory(Names.LogCategory.Hour); }
public ServerService(IServerRepository serverRepository, IPluginRepository pluginRepository, IPluginServerRepository pluginServerRepository, IMcWrapperRepository mcWrapperRepository, IJarService jarService, IMapper mapper, ILogger <ServerService> logger) { _serverRepository = serverRepository; _pluginRepository = pluginRepository; _pluginServerRepository = pluginServerRepository; _mcWrapperRepository = mcWrapperRepository; _jarService = jarService; _mapper = mapper; _logger = logger; }
protected IServerRepository GetEnvironmentRepository() { var models = new List <IServer> { _environmentModel.Object }; var mock = new Mock <IServerRepository>(); CustomContainer.DeRegister <IServerRepository>(); CustomContainer.Register(mock.Object); mock.Setup(s => s.All()).Returns(models); mock.Setup(s => s.Source).Returns(_environmentModel.Object); mock.Setup(repo => repo.Get(It.IsAny <Guid>())).Returns(_environmentModel.Object); mock.Setup(repo => repo.ActiveServer).Returns(_environmentModel.Object); _serverRepo = mock.Object; return(_serverRepo); }
public OwnerModule(DiscordSocketClient client, ISettings settings, ILogger <OwnerModule> logger, IDiscordBotSettingsRepository discordBotSettingsRepository, LavaNode lavaNode, IServerService servers, IServerRepository serverRepository) { _client = client; _settings = settings; _logger = logger; _discordBotSettingsRepository = discordBotSettingsRepository; _lavaNode = lavaNode; _servers = servers; _serverRepository = serverRepository; }
public ViewModelFactory(IMapService mapService, IDialogService dialogService, IWpsClient wpsClient, IContext context, IRequestFactory requestFactory, IServerRepository serverRepository, ILoggerRepository loggerRepository) { _mapService = mapService ?? throw new ArgumentNullException(nameof(mapService)); _dialogService = dialogService ?? throw new ArgumentNullException(nameof(dialogService)); _wpsClient = wpsClient ?? throw new ArgumentNullException(nameof(wpsClient)); _context = context ?? throw new ArgumentNullException(nameof(context)); _requestFactory = requestFactory ?? throw new ArgumentNullException(nameof(requestFactory)); _serverRepository = serverRepository ?? throw new ArgumentNullException(nameof(serverRepository)); _loggerRepository = loggerRepository ?? throw new ArgumentNullException(nameof(loggerRepository)); }
public ServerController(IMapper mapper, IServerRepository repository, ICreateServerUseCase createServerUseCase, CreateServerPresenter createServerPresenter, UpdateServerPresenter updateServerPresenter, IUpdateServerUseCase updateServerUseCase, IBulkServerUseCase bulkServerUseCase, BulkServerPresenter bulkServerPresenter , IExportServerUseCase exportServerUseCase, ExportServerPresenter exportServerPresenter, IReadServerUseCase readServerUseCase)//, ICreateServerUseCase createServerUseCase, CreateServerPresenter createServerPresenter { _mapper = mapper; _repository = repository; _createServerUseCase = createServerUseCase; _readServerUseCase = readServerUseCase; _updateServerUseCase = updateServerUseCase; _bulkServerUseCase = bulkServerUseCase; _createServerPresenter = createServerPresenter; _updateServerPresenter = updateServerPresenter; _bulkServerPresenter = bulkServerPresenter; _exportServerUseCase = exportServerUseCase; _exportServerPresenter = exportServerPresenter; }
//private readonly string _rconPassword; //private readonly string _rconHost; //private readonly int _rconPort; public MiscCommandService( IQueueRepository queueRepository, IFlaggedSubscribersRepository flagRepository, //PickupBotSettings pickupBotSettings, ILogger <MiscCommandService> logger, IServerRepository serverRepository, EncryptionSettings encryptionSettings) { _queueRepository = queueRepository; _flagRepository = flagRepository; _logger = logger; _serverRepository = serverRepository; _encryptionSettings = encryptionSettings; //_rconPassword = pickupBotSettings.RCONServerPassword ?? ""; //_rconHost = pickupBotSettings.RCONHost ?? ""; //int.TryParse(pickupBotSettings.RCONPort ?? "0", out _rconPort); }
public async Task <IJResponse> AdvertiseHeartbeat( [FromServices] IServerRepository serverRepository, [FromBody] JAdvertiseHeartbeatRequest body) { Server server = await serverRepository.GetByToken(body.token); if (server == null) { return(JResponse.Error("Server not registered.")); } server.Players = body.players; server.GameInfo = body.gameInfo; server.LastHeartbeat = DateTime.Now; await serverRepository.AddOrUpdate(server); return(ConvertResponse(JResponse.OK())); }
public static DsfActivity CreateDsfActivity(IContextualResourceModel resource, DsfActivity activity, bool ifNullCreateNew, IServerRepository serverRepository, bool isDesignerLocalhost) { var activityToUpdate = activity; if (activityToUpdate == null) { if (ifNullCreateNew) { if (resource.ServerResourceType == "WebService") { activityToUpdate = new DsfWebserviceActivity(); } else if (resource.ServerResourceType == "PluginService") { activityToUpdate = new DsfPluginActivity(); } else if (resource.ServerResourceType == "DbService") { activityToUpdate = new DsfDatabaseActivity(); } else { activityToUpdate = new DsfActivity(); } } else { return(null); } } if (resource != null) { var activeEnvironment = serverRepository.ActiveServer; activityToUpdate.ResourceID = resource.ID; SetCorrectEnvironmentId(resource, activityToUpdate, isDesignerLocalhost, activeEnvironment); activityToUpdate = SetActivityProperties(resource, activityToUpdate); } activityToUpdate.ExplicitDataList = null; return(activityToUpdate); }
public void Init() { var newServerRepo = new Mock <IServerRepository>(); CreateEnvironmentModel(); _serverRepo = GetEnvironmentRepository(); _popupController = new Mock <IPopupController>(); _eventAggregator = new Mock <IEventAggregator>(); _mockParseServiceForDifferences = new Mock <IServiceDifferenceParser>(); _shellViewModel = new Mock <IShellViewModel>(); _shellViewModel.Setup(model => model.HelpViewModel.UpdateHelpText(It.IsAny <string>())); CustomContainer.Register(newServerRepo.Object); CustomContainer.Register(_shellViewModel.Object); CustomContainer.Register(_popupController.Object); CustomContainer.Register(_mockParseServiceForDifferences.Object); }
public CategoryScoringTask( IServiceFactory <ICategoryScoringLogic, CategoryType> categoryScoreFactory, ICategoryScoreRepository categoryScoreRepository, ICategoryRepository categoryRepository, IServerRepository serverRepository, IMetricDataService metricDataService, IHourRepository hourRepository, IEventRepository eventRepository, ILogger logger) { this.categoryScoreFactory = categoryScoreFactory; this.categoryScoreRepository = categoryScoreRepository; this.categoryRepository = categoryRepository; this.serverRepository = serverRepository; this.metricDataService = metricDataService; this.hourRepository = hourRepository; this.eventRepository = eventRepository; this.logger = logger.WithClassName().WithCategory(Names.LogCategory.CategoryScore); }
void UpdateDesignerAfterResourceLoad(IServerRepository serverRepository) { if (!IsDeleted) { MappingManager.InitializeMappings(); ValidationMemoManager.InitializeLastValidationMemo(_environment); if (IsItemDragged.Instance.IsDragged) { Expand(); IsItemDragged.Instance.IsDragged = false; } } var environmentModel = serverRepository.Get(EnvironmentID); if (EnvironmentID == Guid.Empty) { environmentModel = serverRepository.ActiveServer; } if (environmentModel?.Connection?.WebServerUri != null) { var servUri = new Uri(environmentModel.Connection.WebServerUri.ToString()); var host = servUri.Host; if (!host.Equals(FriendlySourceName, StringComparison.InvariantCultureIgnoreCase)) { FriendlySourceName = host; } } InitializeProperties(); if (_environment != null) { _environment.AuthorizationServiceSet += OnEnvironmentOnAuthorizationServiceSet; AuthorizationServiceOnPermissionsChanged(null, null); } IsLoading = false; if (ResourceModel == null) { ValidationMemoManager.UpdateLastValidationMemoWithSourceNotFoundError(); } }
public ConnectControlViewModel(IServer server, IEventAggregator aggregator, IPopupController popupController, ObservableCollection <IServer> servers) { PopupController = popupController; if (aggregator == null) { throw new ArgumentNullException(nameof(aggregator)); } Server = server ?? throw new ArgumentNullException(nameof(server)); _existingServers = servers; _serverRepository = CustomContainer.Get <IServerRepository>(); LoadServers(); SelectedConnection = server; EditConnectionCommand = new DelegateCommand(AllowConnectionEdit, CanExecuteMethod); NewConnectionCommand = new DelegateCommand(NewServer); if (Server.UpdateRepository != null) { Server.UpdateRepository.ServerSaved += UpdateRepositoryOnServerSaved; } ShouldUpdateActiveEnvironment = false; CanEditServer = true; CanCreateServer = true; }
public AuditBatchProcessor( ISearchAuditBatchRepository searchAuditBatchRepository, IHourRepository hourRepository, ISearchAnalysisService searchAnalysisService, IAuditBatchAnalyzer auditBatchAnalyzer, IWorkspaceAuditServiceFactory workspaceAuditServiceFactory, IWorkspaceAuditReporter workspaceAuditReporter, IServerRepository serverRepository, IAuditParsingService auditParsingService, IWorkspaceService workspaceService, ILogger logger) { this.searchAuditBatchRepository = searchAuditBatchRepository; this.hourRepository = hourRepository; this.searchAnalysisService = searchAnalysisService; this.auditBatchAnalyzer = auditBatchAnalyzer; this.workspaceAuditServiceFactory = workspaceAuditServiceFactory; this.workspaceAuditReporter = workspaceAuditReporter; this.serverRepository = serverRepository; this.auditParsingService = auditParsingService; this.workspaceService = workspaceService; this.logger = logger.WithClassName().WithCategory(Names.LogCategory.Audit); }
public async Task <IJResponse> AdvertiseHeartbeatAsync( [FromServices] IServerRepository serverRepository, [FromBody] JAdvertiseHeartbeatRequest body) { if (string.IsNullOrEmpty(body?.Token)) { return(ConvertResponse(JResponse.Error(JErrorMessages.InvalidToken))); } Server server = await serverRepository.GetByTokenAsync(body.Token); if (server == null) { return(ConvertResponse(JResponse.Error(JErrorMessages.ServerNotRegistered))); } server.Players = body.Players; server.GameInfo = body.GameInfo; server.LastHeartbeat = DateTime.Now; await serverRepository.AddOrUpdateAsync(server); return(ConvertResponse(JResponse.OK())); }
#pragma warning disable 1998 #pragma warning disable 1998 async Task <IRequestServiceNameViewModel> InitializeAsync(IEnvironmentViewModel environmentViewModel, string selectedPath, string header, IExplorerItemViewModel explorerItemViewModel = null) #pragma warning restore 1998 #pragma warning restore 1998 { _environmentViewModel = environmentViewModel; _environmentViewModel.Connect(); _selectedPath = selectedPath; _header = header; _explorerItemViewModel = explorerItemViewModel; OkCommand = new DelegateCommand(SetServiceName, () => string.IsNullOrEmpty(ErrorMessage) && HasLoaded); DuplicateCommand = new DelegateCommand(CallDuplicateService, () => CanDuplicate()); CancelCommand = new DelegateCommand(CloseView, CanClose); Name = header; IsDuplicate = explorerItemViewModel != null; _serverRepository = CustomContainer.Get <IServerRepository>(); if (_serverRepository.ActiveServer == null) { var shellViewModel = CustomContainer.Get <IShellViewModel>(); _serverRepository.ActiveServer = shellViewModel?.ActiveServer; } return(this); }
public async Task <object> GetServers( [FromServices] IServerRepository serverRepository) { try { Server[] servers = await serverRepository.GetAll(); JServer[] jServers = servers.Select(x => JServer.FromServer(x)) .ToArray(); await DoServerCleanup(serverRepository); var response = new JGetServersResponse() { status = JStatus.OK, servers = jServers }; return(ConvertResponse(response)); } catch { return(ConvertResponse(JResponse.Error("Unable to connect to fetch servers."))); } }
public ServerModule(IServerRepository serverRepository, EncryptionSettings encryptionSettings) { _serverRepository = serverRepository; _encryptionSettings = encryptionSettings; }
public ServerRepository(IServerRepository serverRepository) { #pragma warning disable S3010 // For testing _instance = serverRepository; #pragma warning restore S3010 }
public SaveNewWorkflowCallbackHandler(IEventAggregator eventPublisher, IServerRepository currentServerRepository, IContextualResourceModel resourceModel, bool addToTabManager) : base(eventPublisher, currentServerRepository) { AddToTabManager = addToTabManager; _resourceModel = resourceModel; }
static void ReadFileContent(string filePath, IShellViewModel shellViewModel, IFile file, out IContextualResourceModel resourceModel, IServerRepository serverRepo, out IResource resource) { using (var stream = file.OpenRead(filePath)) { using (var streamReader = new StreamReader(stream)) { var resourceContent = streamReader.ReadToEnd(); var serviceXml = XDocument.Parse(resourceContent); resource = shellViewModel.CreateResourceFromStreamContent(resourceContent); resourceModel = ResourceModelFactory.CreateResourceModel(serverRepo.ActiveServer, resource, serviceXml); } } }
public static async Task <IContextualResourceModel> HandleResourceInResourceFolderAndOtherDir(string filePath, Common.Interfaces.Studio.Controller.IPopupController popupController, IShellViewModel shellViewModel, IFile file, IFilePath path, IServerRepository serverRepository) { ReadFileContent(filePath, shellViewModel, file, out IContextualResourceModel resourceModel, serverRepository, out IResource resource); if (resourceModel == null && (resource.ResourceType != "WorkflowService" || resource.ResourceType != "Workflow")) { popupController.ShowSourceAlreadyExistOpenFromResources(); return(resourceModel); } if (resourceModel != null) { resourceModel.IsNewWorkflow = true; resourceModel.IsNotWarewolfPath = true; shellViewModel.OpenResource(resourceModel.ID, shellViewModel.ActiveServer.EnvironmentID, shellViewModel.ActiveServer, resourceModel); } return(resourceModel); }
public static async Task <IContextualResourceModel> HandleResourceNotInResourceFolderAsync(string filePath, Common.Interfaces.Studio.Controller.IPopupController popupController, IShellViewModel shellViewModel, IFile file, IFilePath path, IServerRepository serverRepository) { var saveResource = popupController.ShowResourcesNotInCorrectPath(); if (saveResource == MessageBoxResult.OK) { ReadFileContent(filePath, shellViewModel, file, out IContextualResourceModel resourceModel, serverRepository, out IResource resource); if (resourceModel == null && (resource.ResourceType != "WorkflowService" || resource.ResourceType != "Workflow")) { var moveSource = popupController.ShowCanNotMoveResource() == MessageBoxResult.OK; if (moveSource) { var destination = path.Combine(EnvironmentVariables.ResourcePath, path.GetFileName(filePath)); file.Move(filePath, destination); await shellViewModel.ExplorerViewModel.RefreshEnvironment(serverRepository.ActiveServer.EnvironmentID); resourceModel = serverRepository.ActiveServer.ResourceRepository.LoadContextualResourceModel(resource.ResourceID); } } var ctResourceModel = resourceModel; if (resourceModel != null) { shellViewModel.OpenResource(resourceModel.ID, shellViewModel.ActiveServer.EnvironmentID, shellViewModel.ActiveServer, resourceModel); } return(ctResourceModel); } return(null); }
public VersionTests() { _serverRepository = A.Fake<IServerRepository>(); }
public DeploymentSourceControlService(IServerRepository repository, IServerConfiguration serverConfiguration) { _repository = repository; _serverConfiguration = serverConfiguration; }
public BaseApiController(IServerRepository repository) { _repository = repository; }
public WhenGetServerList(IServerRepository serverRepository, ILocalServerRepository localServerRepository) { _serverRepository = serverRepository; _localServerRepository = localServerRepository; }
public DevilmindAuthorizationFilter(IServerRepository repository) { _repository = repository; }
/// <summary> /// Creates a new <see cref="ServerUnitOfWork"/> /// </summary> /// <param name="context">The DbContext that will be used.</param> /// <param name="serverRepository">The ServerRepository that will be used.</param> public ServerUnitOfWork(BotContext context, IServerRepository serverRepository) { _context = context; Servers = serverRepository; }
public Client(ClientConfiguration clientConfiguration, IServerRepository serverRepository = null) { ClientConfiguration = clientConfiguration; ServerRepository = serverRepository ?? DefaultServerRepository(); }