public object Get(ConfigurationRequest request) { ConfigurationModel configModel; try { var store = GetConfigurationStorage(); var config = store.Load() ?? new Configuration(); // map to ConfigurationModel configModel = Mapper.Map <ConfigurationModel>(config); // strip 'https://' from target host name if (configModel.Target != null && !string.IsNullOrEmpty(configModel.Target.Host) && configModel.Target.Host.StartsWith("http")) { var uri = new Uri(configModel.Target.Host); configModel.Target.Host = uri.Host + uri.PathAndQuery; } } catch (Exception ex) { ex.Message.Error(ex); return(ServerError(ex.Message)); } return(OK(configModel)); }
public async Task PostEnumerableSucceeds() { var requests = new List <ConfigurationRequest>(); var request1 = new ConfigurationRequest { Document = this.TestConfigT1C1.ConfigurationDocument.Document, Target = this.TestConfigT1C1.Target }; var request2 = new ConfigurationRequest { Document = this.TestConfigT2C1.ConfigurationDocument.Document, Target = this.TestConfigT2C1.Target }; requests.Add(request1); requests.Add(request2); var results = await this.controller.Post(requests); var result = await results.ExecuteAsync(CancellationToken.None); Assert.AreEqual(HttpStatusCode.Created, result.StatusCode); var content = await result.Content.ReadAsStringAsync(); var resultContent = JsonConvert.SerializeObject(requests); Assert.AreEqual(resultContent, content); }
public IEnumerable <Configuration> GetConfigurations([FromUri] ConfigurationRequest request) { var configurations = _configurationService.GetConfigurations(request).ToList(); var environments = GetEnvironments().ToList(); foreach (var config in configurations) { var configSettings = config.ConfigurationSettings.ToList(); foreach (var env in environments) { var emptySettings = config.ConfigurationType.Settings.Where(s => !configSettings.Any(cs => cs.EnvironmentID == env.EnvironmentID && cs.SettingID == s.SettingID)); emptySettings.ForEach(es => { configSettings.Add(new ConfigurationSetting { ConfigurationID = config.ConfigurationID, EnvironmentID = env.EnvironmentID, Environment = env, SettingID = es.SettingID, Setting = es }); }); } config.ConfigurationSettings = configSettings.OrderBy(cs => cs.SettingID).ToList(); } return(configurations); }
public async override Task GetConfiguration(ConfigurationRequest req, IServerStreamWriter <ConfigurationContainer> serverStream, ServerCallContext context) { SessionSettings session; Collector collector; if (state.SessionStorages.TryPeek(out session) && state.Collectors.TryGetValue(req.Group, out ConcurrentBag <Collector> Collectors) && Collectors.TryTake(out collector)) { ConfigurationContainer cont = new ConfigurationContainer() { Session = session, CollectorParams = collector }; await serverStream.WriteAsync(cont); try { await Task.Delay(-1, context.CancellationToken); } catch (TaskCanceledException) { state.Collectors[req.Group].Add(collector); } } }
public object Get(ConfigurationRequest request) { ConfigurationModel configModel; try { var store = GetConfigurationStorage(); var config = store.Load() ?? new Configuration(); // map to ConfigurationModel configModel = Mapper.Map<ConfigurationModel>(config); // strip 'https://' from target host name if (configModel.Target != null && !string.IsNullOrEmpty(configModel.Target.Host) && configModel.Target.Host.StartsWith("http")) { var uri = new Uri(configModel.Target.Host); configModel.Target.Host = uri.Host + uri.PathAndQuery; } } catch (Exception ex) { ex.Message.Error(ex); return ServerError(ex.Message); } return OK(configModel); }
public async Task <ConfigurationResponse> PutConfiguration(int id, ConfigurationRequest model) { var config = await _unitOfWork.Repository <Config>().GetById(id); if (config != null) { try { config.Value = model.Value; await _unitOfWork.Repository <Config>().Update(config, id); await _unitOfWork.CommitAsync(); return(new ConfigurationResponse { Id = config.Id, Name = config.Name, Value = config.Value, Version = config.Version, Active = config.Active, Description = config.Description }); } catch (Exception e) { throw new CrudException(HttpStatusCode.BadRequest, "Update Config Error!!!", e.InnerException?.Message); } } else { return(null); } }
private IEnumerable <Configuration> GetConfigurationsInternal(ConfigurationRequest request) { var query = _configurationRepository.GetAll <Configuration>() .Include("ConfigurationType") .Include("ConfigurationType.Settings") .Include("ConfigurationSettings") .Include("ConfigurationSettings.Environment") .Include("ConfigurationSettings.Setting"); if (request.ConfigurationID > 0) { query = query.Where(c => c.ConfigurationID == request.ConfigurationID); } if (request.ConfigurationTypeID > 0) { query = query.Where(c => c.ConfigurationTypeID == request.ConfigurationTypeID); } if (!string.IsNullOrEmpty(request.ConfigurationName)) { query = query.Where(c => c.Name.Equals(request.ConfigurationName, StringComparison.InvariantCultureIgnoreCase)); } if (!string.IsNullOrEmpty(request.ConfigurationTypeName)) { query = query.Where(c => c.ConfigurationType.Name.Equals(request.ConfigurationTypeName, StringComparison.InvariantCultureIgnoreCase)); } return(query.ToList()); }
public override Task <Configuration> GetConfiguration(ConfigurationRequest request, ServerCallContext context) { return(Task.FromResult(new Configuration { SearchExpirationInSeconds = Convert.ToInt64(TimeSpan.FromDays(7).TotalSeconds), StreamExpirationInSeconds = Convert.ToInt64(TimeSpan.FromMinutes(30).TotalSeconds), })); }
public IActionResult GetConfigurationById([FromBody] ConfigurationRequest model) { try { response = _clientService.GetConfigurationById(model); var json = JsonConvert.SerializeObject(response, _serializerSettings); return(new OkObjectResult(json)); } catch { throw; } }
private static bool ParseActions(string[] args) { return(Parser.Default.ParseArguments <ConfigOption, ServerListOption>(args) .MapResult( (ConfigOption opt) => { var handler = ServicesContainer.Container.Resolve <IHandler <ConfigurationRequest> >(); var request = new ConfigurationRequest { UserName = opt.UserName, Password = opt.Password }; try { handler.HandleAsync(request).Wait(); } catch (Exception e) { Console.WriteLine(e.Message); return false; } return true; }, (ServerListOption opt) => { var handler = ServicesContainer.Container.Resolve <IHandler <ServerListRequest> >(); var request = new ServerListRequest { Local = opt.Local }; try { handler.HandleAsync(request).Wait(); } catch (Exception e) { Console.WriteLine(e.Message); return false; } return true; }, errors => { var logger = ServicesContainer.Container.Resolve <ILogger>(); errors.ToList().ForEach(err => logger.Error("Parsing error {error}", err)); return true; })); }
public ActionResult <Configuration> Save([FromBody] ConfigurationRequest configurationRequest) { var configuration = new Configuration { Id = Guid.NewGuid(), Name = configurationRequest.Name, Grid = configurationRequest.Grid }; return(_service.add(configuration)); }
public ActionResult <Configuration> Update([FromRoute] Guid id, [FromBody] ConfigurationRequest configurationRequest) { var configuration = new Configuration { Id = id, Name = configurationRequest.Name, Grid = configurationRequest.Grid }; return(_service.update(configuration)); }
public void RequiredFieldsTests() { var credentialsServiceMock = new Mock <ICredentialsRepository>(); var handler = new ConfigurationHandler(credentialsServiceMock.Object, new Mock <IDisplayService>().Object) { Validator = new ConfigurationRequestValidator() }; ConfigurationRequest request = new ConfigurationRequest(); Assert.ThrowsAsync <ValidationException>(() => handler.HandleAsync(request)); }
private static StoreConfigurationCommand MapCommand(ConfigurationRequest request) { return(new StoreConfigurationCommand( request.ConnectionString, request.ConnectionStringAdmin, request.RabbitMqHostName, request.RabbitMqUserName, request.RabbitMqPassword, request.FacebookAppId, request.FacebookAppSecret, request.GoogleClientId, request.GoogleClientSecret )); }
public async Task <ActionResult> Index(ConfigurationRequest request) { if (_configuration.GeneralConfigured()) { return(RedirectToAction("Index", "Home")); } var command = MapCommand(request); var result = await _messageDispatcher.Execute(command); if (!result.Succeeded) { return(BadRequest()); } return(View(new InstallationResponse(true))); }
/// <summary> /// The publish. /// </summary> /// <param name="document"> /// The document. /// </param> /// <param name="target"> /// The target. /// </param> /// <param name="certificateThumbprint"> /// The certificate thumbprint. /// </param> public void Publish(string document, string target, string certificateThumbprint) { var configuration = new ConfigurationRequest { Document = document, Target = target, CertificateThumbprint = certificateThumbprint }; var entities = this.Repository.Where(c => c.Target == configuration.Target && c.ArchiveTimestamp == null); foreach (var entity in entities) { entity.ArchiveTimestamp = DateTime.UtcNow; this.Context.Entry(entity).State = EntityState.Modified; this.Logging?.ConfigurationArchived(entity.Target, entity.ConfigurationDocumentId); } var config = configuration.ToModel(); this.Repository.Add(config); this.Context.SaveChanges(); this.Logging?.ConfigurationPublished(config.Target, config.ConfigurationDocumentId); }
/// <summary> /// Create new configurations /// </summary> /// <param name="clusterName"></param> /// <param name="body"></param> /// <returns></returns> public void CreateConfigurations(string clusterName, ConfigurationRequest body) { // verify the required parameter 'clusterName' is set if (clusterName == null) { throw new ApiException(400, "Missing required parameter 'clusterName' when calling CreateConfigurations"); } var path = "/clusters/{clusterName}/configurations"; path = path.Replace("{format}", "json"); path = path.Replace("{" + "clusterName" + "}", ApiClient.ParameterToString(clusterName)); var queryParams = new Dictionary <String, String>(); var headerParams = new Dictionary <String, String>(); var formParams = new Dictionary <String, String>(); var fileParams = new Dictionary <String, FileParameter>(); String postBody = null; postBody = ApiClient.Serialize(body); // http body (model) parameter // authentication setting, if any String[] authSettings = new String[] { }; // make the HTTP request IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings); if (((int)response.StatusCode) >= 400) { throw new ApiException((int)response.StatusCode, "Error calling CreateConfigurations: " + response.Content, response.Content); } else if (((int)response.StatusCode) == 0) { throw new ApiException((int)response.StatusCode, "Error calling CreateConfigurations: " + response.ErrorMessage, response.ErrorMessage); } return; }
public APIResponse.APIResponse GetConfigurationById(ConfigurationRequest model) { try { Configuration data = _IConfigureRepository.GetSingle(x => x.ConfigurationId == model.ConfigurationId); ConfigurationResponse configurationDataResponse = _mapper.Map <ConfigurationResponse>(data); if (configurationDataResponse != null) { response.StatusCode = StaticResource.StaticResource.successStatusCode; response.data.Configure = configurationDataResponse; } else { response.StatusCode = StaticResource.StaticResource.failStatusCode; response.Message = StaticResource.StaticResource.NoConfigurationFound; } } catch { response.StatusCode = StaticResource.StaticResource.failStatusCode; response.Message = StaticResource.StaticResource.SomethingWrong; } return(response); }
public IEnumerable <Configuration> GetConfigurations(ConfigurationRequest request) { return(request.UseCache ? _cacheStorage.Retrieve("AppService.Configurations", () => GetConfigurationsInternal(request)) : GetConfigurationsInternal(request)); }
public void Connect(string serverName, string defaultApplication) { var server = (from ServerElement element in _config.ServerCollection where element.Name == serverName select element).LastOrDefault(); _client = new ThinClient(server.HostName, server.Port); _client.ConnectTimeout = _config.ConnectTimeout * 1000; _client.ReceiveTimeout = _config.ReceiveTimeout * 1000; _client.SendTimeout = _config.SendTimeout * 1000; ConfigurationRequest request = new ConfigurationRequest(); ConfigurationResponse response = null; int callCount = 0; while (true) { DateTime startTime = DateTime.Now; try { callCount++; response = _client.Invoke <ConfigurationRequest, ConfigurationResponse>(request); break; } catch (ServerFaultException ex) { HandleServerFaultException(ex); return; } catch (Exception ex) { if (callCount >= _config.RetryCount + 1) { callCount = 0; if (MessageBox.Show(string.Format("Unable to contact the server. Do you want to retry?\n\n{0}", ex.Message), _form.Text, MessageBoxButtons.RetryCancel, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1) == System.Windows.Forms.DialogResult.Cancel) { return; } } else { TimeSpan processingTime = DateTime.Now - startTime; if (processingTime.TotalMilliseconds < _client.ConnectTimeout) { int sleepTime = _client.ConnectTimeout - (int)processingTime.TotalMilliseconds; Thread.Sleep(sleepTime); } } } } using (ApplicationForm applicationForm = new ApplicationForm()) { _form.Visible = false; try { applicationForm.Presenter.Client = _client; applicationForm.Presenter.NativeDriver = _nativeDriver; applicationForm.Presenter.Config = _config; applicationForm.Presenter.ServerConfiguration = response; applicationForm.Presenter.DefaultApplication = defaultApplication; applicationForm.Left = _form.Left; applicationForm.Top = _form.Top; applicationForm.Width = _form.Width; applicationForm.Height = _form.Height; applicationForm.ShowDialog(); } finally { _form.Visible = true; } } }
public async Task <ActionResult <ConfigurationResponse> > UpdateConfig(int id, [FromBody] ConfigurationRequest model) { var rs = await _configurationService.PutConfiguration(id, model); return(Ok(rs)); }
public IEnumerable <Configuration> GetConfigurations(ConfigurationRequest request) { var proxy = _configurationService.CreateProxy(); return(proxy.GetConfigurations(request)); }
private void OnFcsConfigChange(object sender, ConfigurationRequest e) { log.Debug("GradesViewModel: Fcs configuration is changed.Get grades."); GetGrades(); }
private void OnFCSConfigReceived(object sender, ConfigurationRequest config) { log.Debug("App: fcs configuration is received."); posManager = Mvx.IoCProvider.Resolve <PosManager>(); posManager.StartPos(); }
private void OpenConfiguration() { ConfigurationRequest.Raise(new Confirmation { Title = "Phoenix 設定" }); }