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 設定"
});
}
