Exemplo n.º 1
0
 public DropboxHandler(ITracer tracer,
                       IServerRepository repository,
                       IDeploymentSettingsManager settings,
                       IEnvironment environment)
 {
     _tracer = tracer;
     _helper = new DropboxHelper(tracer, repository, settings, environment);
 }
Exemplo n.º 2
0
 public ProxyService(IHgServer hgServer,
                     IServerConfiguration configuration,
                     IDeploymentManager deploymentManager,
                     IServerRepository severRepository)
 {
     _hgServer = hgServer;
     _configuration = configuration;
     _deploymentManager = deploymentManager;
     _severRepository = severRepository;
 }
Exemplo n.º 3
0
 public DropboxHelper(ITracer tracer, 
                      IServerRepository repository, 
                      IDeploymentSettingsManager settings, 
                      IEnvironment environment)
 {
     _tracer = tracer;
     _repository = repository;
     _settings = settings;
     _environment = environment;
 }
Exemplo n.º 4
0
 public DropboxHelper(ITracer tracer,
                      IServerRepository repository,
                      IDeploymentSettingsManager settings,
                      IEnvironment environment)
 {
     _tracer = tracer;
     _repository = repository;
     _settings = settings;
     _environment = environment;
     _timeout = settings.GetCommandIdleTimeout();
 }
Exemplo n.º 5
0
 public LiveScmController(ITracer tracer,
                          IOperationLock deploymentLock,
                          IEnvironment environment,
                          IServerRepository repository,
                          IServerConfiguration serverConfiguration)
 {
     _tracer = tracer;
     _deploymentLock = deploymentLock;
     _environment = environment;
     _repository = repository;
     _serverConfiguration = serverConfiguration;
 }
Exemplo n.º 6
0
 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;
 }
Exemplo n.º 7
0
        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));
        }
Exemplo n.º 8
0
        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);
        }
Exemplo n.º 9
0
 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>();
 }
Exemplo n.º 10
0
 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;
 }
Exemplo n.º 11
0
 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;
 }
Exemplo n.º 12
0
 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);
 }
Exemplo n.º 14
0
 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;
 }
Exemplo n.º 15
0
        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);
        }
Exemplo n.º 16
0
 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;
 }
Exemplo n.º 17
0
 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));
 }
Exemplo n.º 18
0
 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;
 }
Exemplo n.º 19
0
        //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);
        }
Exemplo n.º 20
0
        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);
        }
Exemplo n.º 22
0
        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);
        }
Exemplo n.º 23
0
 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);
 }
Exemplo n.º 24
0
        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);
 }
Exemplo n.º 27
0
        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()));
        }
Exemplo n.º 28
0
#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);
        }
Exemplo n.º 29
0
        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.")));
            }
        }
Exemplo n.º 30
0
 public ServerModule(IServerRepository serverRepository, EncryptionSettings encryptionSettings)
 {
     _serverRepository   = serverRepository;
     _encryptionSettings = encryptionSettings;
 }
Exemplo n.º 31
0
        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;
 }
Exemplo n.º 33
0
 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);
         }
     }
 }
Exemplo n.º 34
0
 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);
 }
Exemplo n.º 35
0
        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);
        }
Exemplo n.º 36
0
 public VersionTests()
 {
     _serverRepository = A.Fake<IServerRepository>();
 }
Exemplo n.º 37
0
 public DeploymentSourceControlService(IServerRepository repository, IServerConfiguration serverConfiguration)
 {
     _repository = repository;
     _serverConfiguration = serverConfiguration;
 }
Exemplo n.º 38
0
 public BaseApiController(IServerRepository repository)
 {
     _repository = repository;
 }
Exemplo n.º 39
0
 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;
 }
Exemplo n.º 42
0
 public Client(ClientConfiguration clientConfiguration, IServerRepository serverRepository = null)
 {
     ClientConfiguration = clientConfiguration;
     ServerRepository = serverRepository ?? DefaultServerRepository();
 }