public GetFromVCSCommand(EnvironmentSettings settings, string remotePath, string localPath, string comment, string workingDir)
{
this.remotePath = remotePath;
this.localPath = localPath;
this.comment = comment;
this.workingDir = workingDir;
this.settings = settings;
}
public GetInstallDNXScriptComamnd(EnvironmentSettings settings, DNXSettings dnxsettings) :
base(
settings,
Path.Combine(settings.RemoteSettingsPath, "dnxInstall.sh"),
settings.WorkingDir,
"get installation script",
settings.WorkingDir)
{
}
public InstallPackageCommand(EnvironmentSettings settings, CoreClrProject project)
: this(settings) {
this.settings = settings;
pathToPackage = string.Format(
@"{0}\bin\{1}\{2}",
project.LocalPath,
project.BuildConfiguration,
project.NugetPackageName);
}
public void HaveTestEnvironmentWhenTestEnvironmentIsAdded()
{
var source = new TestSettingSource();
var envs = new EnvironmentSettings(new SettingsManager(new SecureSettingsManager(source)));
var env = new EnvironmentSetting("test", "test", "test", "test");
envs.AddEnvironment(env);
Assert.IsTrue(envs.Any(e => e.Name == env.Name));
}
public GetProductConfigCommand(EnvironmentSettings settings) :
base(settings,
Path.Combine(settings.RemoteSettingsPath,"Product.xml"),
settings.WorkingDir,
"Get Product.xml",
settings.WorkingDir)
{
productConfig = settings.ProductConfig;
}
public GetNugetConfigCommand(EnvironmentSettings settings, DNXSettings dnxsettings) :
base(
settings,
string.Format("$/{0}/NetCore/NuGet.Config", settings.BranchVersion),
PlatformPathsCorrector.Inst.Correct(@"NetCore\", Platform.Windows),
"get nuget.config",
settings.WorkingDir)
{
workingDir = settings.WorkingDir;
}
public void BeAbleToRemoveTestEnvironmentAfterTestEnvironmentIsAdded()
{
var source = new TestSettingSource();
var envs = new EnvironmentSettings(new SettingsManager(new SecureSettingsManager(source)));
var env = new EnvironmentSetting("test", "test", "test", "test");
envs.AddEnvironment(env);
envs.RemoveEnvironment(env);
Assert.IsFalse(envs.Any(e => e.Name == env.Name));
}
public CollectArtifactsCommand(EnvironmentSettings settings, ProjectsInfo info, string destFolder, string buildFramework)
{
this.settings = settings;
this.info = info;
if (!string.IsNullOrEmpty(buildFramework))
this.destFolder = string.Format(@"{0}\{1}", destFolder, buildFramework);
else
this.destFolder = destFolder;
}
public CollectArtifactsCommand(EnvironmentSettings settings, ProjectsInfo info, string destFolder, string runtime, string buildFramework)
{
this.settings = settings;
this.info = info;
if (!string.IsNullOrEmpty(buildFramework) && !string.IsNullOrEmpty(runtime))
this.destFolder = PlatformPathsCorrector.Inst.Correct(string.Format(@"{0}\{1}\{2}", destFolder, runtime, buildFramework), Platform.Windows);
else
this.destFolder = destFolder;
}
public void IsValid_Throws_IfPostBuildScriptPath_IsNotPresent()
{
// Arrange
var environmentSettings = new EnvironmentSettings();
environmentSettings.PostBuildScriptPath = Path.Combine(_tempDirRoot, Guid.NewGuid().ToString());
var sourceDir = CreateNewDir();
var provider = CreateProvider(sourceDir);
// Act
var exception = Assert.Throws <InvalidUsageException>(() => provider.IsValid(environmentSettings));
// Assert
Assert.Equal(
$"Post-build script file '{environmentSettings.PostBuildScriptPath}' does not exist.",
exception.Message);
}
public void Execute(AddReferenceCommandInput input, EnvironmentSettings settings, IFileSystem fileSystem, DeploymentSettings deploymentSettings)
{
string bottleText = "bottle:{0}".ToFormat(input.Bottle);
var hostPath = deploymentSettings.GetHost(input.Recipe, input.Host);
Console.WriteLine("Analyzing the host file at " + input.Host);
fileSystem.AlterFlatFile(hostPath, list =>
{
list.Fill(bottleText);
list.Sort();
Console.WriteLine("Contents of file " + hostPath);
list.Each(x => Console.WriteLine(" " + x));
});
}
public void GenerateSampleApplicationSettings()
{
var settings = new EnvironmentSettings();
settings.couchbaseServers = new List <CouchbaseServer>();
settings.couchbaseServers.Add(new CouchbaseServer()
{
id = "default",
uri = "couchbase://127.0.0.1",
bucketName = "couch",
bucketPassword = "******"
});
settings.primaryCouchbaseServer = "default";
settings.sqlServers = new List <SQLServer>();
settings.sqlServers.Add(new SQLServer()
{
id = "default",
connectionString = "Server=localhost;"
});
settings.primarySqlServer = "default";
settings.contentStorages = new List <StorageLocation>();
settings.contentStorages.Add(
new StorageLocation()
{
id = "default",
path = "D:\\_contents"
});
settings.primaryContentStorage = "default";
settings.applicationStorages = new List <StorageLocation>();
settings.applicationStorages.Add(
new StorageLocation()
{
id = "default",
path = "D:\\_webs"
});
settings.primaryApplicationStorage = "default";
string serialized = Newtonsoft.Json.JsonConvert.SerializeObject(settings, Newtonsoft.Json.Formatting.Indented);
}
public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
{
if (Settings == null)
{
return;
}
if (material == null)
{
return;
}
try
{
bool globalSnow = Settings.GetBooleanPropertyValue("GlobalSnow");
if (globalSnow)
{
material.SetFloat("_Snow_Amount", environmentSettings.SnowAmount * 2f);
}
else
{
float snowAmount = Settings.GetFloatPropertyValue("SnowAmount");
material.SetFloat("_Snow_Amount", snowAmount * 2f);
}
material.SetFloat("_CullFarStart", 10000);
material.SetFloat("_SnowColorBrightness", Settings.GetFloatPropertyValue("SnowColorBrightness"));
material.SetColor("_HealthyColor", Settings.GetColorPropertyValue("HealthyColorTint"));
material.SetColor("_DryColor", Settings.GetColorPropertyValue("DryColorTint"));
material.SetFloat("_ColorNoiseSpread", Settings.GetFloatPropertyValue("ColorNoiseSpread"));
material.SetFloat("_Cutoff", Settings.GetFloatPropertyValue("AlphaCutoff"));
material.SetFloat("_InitialBend", Settings.GetFloatPropertyValue("InitialBend"));
material.SetFloat("_Stiffness", Settings.GetFloatPropertyValue("Stiffness"));
material.SetFloat("_Drag", Settings.GetFloatPropertyValue("Drag"));
material.SetFloat("_ShiverDrag", Settings.GetFloatPropertyValue("ShiverDrag"));
material.SetFloat("_ShiverDirectionality", Settings.GetFloatPropertyValue("ShiverDirectionality"));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/* setting value to null will delete the entry */
WindLightSettings ISimulationDataEnvSettingsStorageInterface.this[UUID regionID]
{
get
{
WindLightSettings settings;
if (!EnvironmentSettings.TryGetValue(regionID, out settings))
{
throw new KeyNotFoundException();
}
return(settings);
}
set
{
using (var conn = new MySqlConnection(m_ConnectionString))
{
conn.Open();
if (value == null)
{
#if DEBUG
m_Log.DebugFormat("Removing environment settings for {0}", regionID.ToString());
#endif
using (var cmd = new MySqlCommand("DELETE FROM environmentsettings WHERE RegionID = @regionid", conn))
{
cmd.Parameters.AddParameter("@regionid", regionID);
cmd.ExecuteNonQuery();
}
}
else
{
#if DEBUG
m_Log.DebugFormat("Storing new environment settings for {0}", regionID.ToString());
#endif
var param = new Dictionary <string, object>
{
["RegionID"] = regionID
};
using (var ms = new MemoryStream())
{
value.Serialize(ms, regionID);
param["EnvironmentSettings"] = ms.ToArray();
}
conn.ReplaceInto("environmentsettings", param);
}
}
}
}
public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
{
if (Settings == null)
{
return;
}
material.SetFloat("_BaseSmoothness", Settings.GetFloatPropertyValue("BaseSmoothness"));
material.SetFloat("_BaseAOIntensity", Settings.GetFloatPropertyValue("BaseAOIntensity"));
material.SetColor("_BaseColor", Settings.GetColorPropertyValue("BaseColor"));
material.SetFloat("_TopIntensity", Settings.GetFloatPropertyValue("TopIntensity"));
material.SetFloat("_TopOffset", Settings.GetFloatPropertyValue("TopOffset"));
material.SetFloat("_TopContrast", Settings.GetFloatPropertyValue("TopContrast"));
material.SetFloat("_TopNormalIntensity", Settings.GetFloatPropertyValue("TopNormalIntensity"));
material.SetColor("_TopColor", Settings.GetColorPropertyValue("TopColor"));
}
public static HostManifest ReadFrom(string fileName, EnvironmentSettings environment)
{
var parser = new SettingsParser(fileName, environment.Overrides.ToDictionary());
new FileSystem().ReadTextFile(fileName, parser.ParseText);
var hostName = Path.GetFileNameWithoutExtension(fileName);
var host = new HostManifest(hostName);
var settings = parser.Settings;
host.RegisterSettings(settings);
host.RegisterBottles(parser.References);
return(host);
}
public BotCompiler(BotMeta botMeta, string botDir, ILogger compileLogger, EnvironmentSettings environmentSettings)
{
_botMeta = botMeta;
_botDir = botDir;
this._compileLogger = compileLogger;
switch (botMeta.BotType)
{
case BotMeta.BotTypes.JavaScript:
_compiler = new JavaScriptCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
case BotMeta.BotTypes.Java:
_compiler = new JavaCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
case BotMeta.BotTypes.Julia:
_compiler = new JuliaCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
case BotMeta.BotTypes.Python2:
case BotMeta.BotTypes.Python3:
_compiler = new PythonCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
case BotMeta.BotTypes.Golang:
_compiler = new GolangCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
case BotMeta.BotTypes.Rust:
_compiler = new RustCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
case BotMeta.BotTypes.FSharp:
throw new ArgumentException("F# is not supported (No sample bot submitted)");
case BotMeta.BotTypes.CPlusPlus:
_compiler = new DotNetCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
default:
_compiler = new DotNetCompiler(botMeta, botDir, compileLogger, environmentSettings);
break;
}
}
public UserControllerTests()
{
_loggerMock = new Mock <ILogger <UserController> >();
EnvironmentSettings envSettings = new EnvironmentSettings()
{
BaseUrl = "http://localhost:3000/", JwtSecret = "DoNotUseMeInProduction", Environment = "Development"
};
_envSettingsMock = new Mock <IOptions <EnvironmentSettings> >();
_envSettingsMock.Setup(x => x.Value).Returns(envSettings);
LdapSettings ldapSettings = new LdapSettings()
{
BaseDN = "5", HostName = "4", Port = "123", SecureSocketLayer = "false"
};
_ldapSettings = new Mock <IOptions <LdapSettings> >();
_ldapSettings.Setup(x => x.Value).Returns(ldapSettings);
}
public Step(
ScenarioContext scenarioContext,
FeatureContext featureContext,
HttpHelper httphelper,
EnvironmentSettings settings,
HttpResponseHelper assertHelper,
SqlHelper sqlhelper,
CosmosHelper cosmosHelper)
{
_scenarioContext = scenarioContext;
_featureContext = featureContext;
_settings = settings;
_httpHelper = httphelper;
_assertionHelper = assertHelper;
_sqlHelper = sqlhelper;
_cosmosHelper = cosmosHelper;
_touchPointId = _settings.TestEndpoint01;
}
private static CloudBornWorkerConfiguration CreateConfiguration(ICodePackageActivationContext activationContext)
{
var configurationPackage = activationContext.GetConfigurationPackageObject("Config");
ConfigurationSection serviceEnvironmentSection = configurationPackage.Settings.Sections["ServiceEnvironment"];
string dataCenter = serviceEnvironmentSection.Parameters["DataCenterName"].Value;
string environmentSettingsResourceName = serviceEnvironmentSection.Parameters["EnvironmentSettingsResourceName"].Value;
EnvironmentSettings environmentSettings = EnvironmentSettingsLoader.Load(environmentSettingsResourceName);
ConfigurationSection workerSection = configurationPackage.Settings.Sections["CloudBornWorker"];
TimeSpan monitoringJobInterval = TimeSpan.FromMinutes(double.Parse(workerSection.Parameters["MonitoringJobIntervalInMinutes"].Value, CultureInfo.InvariantCulture));
string externalPrincipals = environmentSettings.MonitoringAllowedExternalPrincipals;
return(new CloudBornWorkerConfiguration(
dataCenter,
monitoringJobInterval,
externalPrincipals));
}
public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
{
if (Settings == null)
{
return;
}
material.SetFloat("_AmbientOcclusion", Settings.GetFloatPropertyValue("AmbientOcclusion"));
material.SetFloat("_TransmissionAmount", Settings.GetFloatPropertyValue("TranslucencyAmount"));
material.SetFloat("_TransmissionSize", Settings.GetFloatPropertyValue("TranslucencySize"));
material.SetFloat("_MaxWindStrength", Settings.GetFloatPropertyValue("WindInfluence"));
material.SetFloat("_GlobalWindMotion", Settings.GetFloatPropertyValue("GlobalWindMotion"));
material.SetFloat("_LeafFlutter", Settings.GetFloatPropertyValue("LeafFlutter"));
material.SetFloat("_WindSwinging", Settings.GetFloatPropertyValue("WindSwinging"));
material.SetFloat("_WindAmplitudeMultiplier", Settings.GetFloatPropertyValue("WindAmplitude"));
}
public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
{
if (Settings == null)
{
return;
}
material.SetColor("_Color", Settings.GetColorPropertyValue("TintColor1"));
material.SetColor("_ColorB", Settings.GetColorPropertyValue("TintColor2"));
material.SetFloat("_Cutoff", Settings.GetFloatPropertyValue("AlphaCutoff"));
material.SetFloat("_RandomDarkening", Settings.GetFloatPropertyValue("RandomDarkening"));
material.SetFloat("_RootAmbient", Settings.GetFloatPropertyValue("RootAmbient"));
Vector4 colorScale = material.GetVector("_AG_ColorNoiseArea");
colorScale = new Vector4(colorScale.x, Settings.GetFloatPropertyValue("TintAreaScale"), colorScale.z, colorScale.w);
material.SetVector("_AG_ColorNoiseArea", colorScale);
}
public static void InitializeScenario()
{
// write any initialization which you want to apply once for every scenario
var _settings = new EnvironmentSettings();
Threaded <Session>
.With <LocalEnvironment>()
.NavigateTo <HomePage>(_settings.BaseUrl);
ScenarioContext.Current.AddOrUpdate(typeof(Cleaner).FullName, new Cleaner());
//AFSession
// .With(TestRunHooks.Bootstrapper)
// .NavigateToPageInSettings<AuthorizationPage>();
// ScenarioContext.Current.AddOrUpdate(typeof(Cleaner).FullName, new Cleaner());
}
public void RestartCommand_FormsCorrectApplicationRequest_WhenApplicationRunsUnderNetCoreAndSettingsPickedFromEnvironment()
{
IApplicationClient applicationClient = Substitute.For <IApplicationClient>();
var environmentSettings = new EnvironmentSettings {
Login = "******",
Password = "******",
IsNetCore = true,
Maintainer = "Test",
Uri = "http://test.domain.com"
};
RestartCommand restartCommand = new RestartCommand(applicationClient, environmentSettings);
var options = Substitute.For <RestartOptions>();
restartCommand.Execute(options);
applicationClient.Received(1).ExecutePostRequest(
environmentSettings.Uri + "/ServiceModel/AppInstallerService.svc/RestartApp",
"{}", Timeout.Infinite);
}
public static Container Initialize(EnvironmentSettings envSettings)
{
return(new Container(
_ =>
{
_.For <IBuilding>().Use <Building>();
_.For <RobotFactory>().Use <RobotSpiderFactory>();
_.For <IRobotLogger>().Use <RobotSpiderLogger>();
_.For <IInstructionParser>().Use <InstructionParser>();
_.For <IUpdateLocationStrategy>().Use <UpdateLocationStrategy>();
_.For <MovementFactory>().Use <MovementStrategyFactory>();
_.For <IMovementStrategy>().Use <SpiderMovementStrategy>();
_.For <ISettings>().Use <Settings>();
_.For <CompositeSpecification <GridSize> >().Use <GridSizeSpecification>();
_.For <CompositeSpecification <Point> >().Use <InitialLocationSpecification>();
_.For <CompositeSpecification <string> >().Use <InstructionSetSpecification>().Ctor <IList <char> >().Is(GetValidCharacters());
}));
}
public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
{
if (Settings == null)
{
return;
}
Color foliageHueVariation = Settings.GetColorPropertyValue("FoliageHue");
Color barkHueVariation = Settings.GetColorPropertyValue("BarkHue");
Color foliageTintColor = Settings.GetColorPropertyValue("FoliageTintColor");
Color barkTintColor = Settings.GetColorPropertyValue("BarkTintColor");
bool replaceShader = Settings.GetBooleanPropertyValue("ReplaceShader");
if (material.HasProperty("_Cutoff"))
{
material.SetFloat("_Cutoff", material.GetFloat("_Cutoff"));
}
if (HasKeyword(material, "GEOM_TYPE_BRANCH"))
{
material.SetColor("_HueVariation", barkHueVariation);
material.SetColor("_Color", barkTintColor);
}
else
{
material.SetColor("_HueVariation", foliageHueVariation);
material.SetColor("_Color", foliageTintColor);
}
if (replaceShader)
{
if (material.shader.name == "Nature/SpeedTree")
{
material.shader = Shader.Find("AwesomeTechnologies/VS_SpeedTree");
}
}
//else
//{
// if (material.shader.name != "Nature/SpeedTree")
// {
// material.shader = Shader.Find("Nature/SpeedTree");
// }
//}
}
public override async Task RunCommand(object sender)
{
var engine = (IAutomationEngineInstance)sender;
var vTaskId = (Guid)await v_TaskId.EvaluateCode(engine);
var vAwaitCompletion = (bool)await v_AwaitCompletion.EvaluateCode(engine);
string vUsername;
string vPassword;
var environmentSettings = new EnvironmentSettings();
environmentSettings.Load();
AuthMethods authMethods = new AuthMethods();
authMethods.Initialize(environmentSettings.ServerType, environmentSettings.OrganizationName, environmentSettings.ServerUrl, environmentSettings.Username, environmentSettings.Password);
if (environmentSettings.ServerType == "Local")
{
throw new Exception("Documents commands cannot be used with local Server");
}
else
{
vUsername = environmentSettings.Username;
vPassword = environmentSettings.Password;
}
var userInfo = authMethods.GetDocumentsAuthToken(vUsername, vPassword);
DocumentStatus docStatus = DocumentMethods.GetDocumentStatus(userInfo, vTaskId);
if (vAwaitCompletion)
{
int vTimeout = (int)await v_Timeout.EvaluateCode(engine);
docStatus = DocumentMethods.AwaitProcessing(userInfo, vTaskId, vTimeout);
}
docStatus.Status.SetVariableValue(engine, v_OutputUserVariableName);
docStatus.IsDocumentCompleted.SetVariableValue(engine, v_OutputUserVariableName1);
docStatus.HasError.SetVariableValue(engine, v_OutputUserVariableName2);
docStatus.IsCurrentlyProcessing.SetVariableValue(engine, v_OutputUserVariableName3);
docStatus.IsSuccessful.SetVariableValue(engine, v_OutputUserVariableName4);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddHttpClient();
services.AddHttpClient <IWeatherDataRepository, WeatherDataRepository>();
services.AddTransient <IPlaylistRepository, PlaylistRepository>();
services.AddMediatR(typeof(GetPlaylistForCityQuery).GetTypeInfo().Assembly);
services.AddTransient(typeof(IPipelineBehavior <,>), typeof(RequestValidationBehavior <,>));
services.AddSingleton <IClock>(SystemClock.Instance);
services.AddTransient <EnvironmentSettings>(s =>
{
EnvironmentSettings settings = new EnvironmentSettings();
var builder = new ConfigurationBuilder()
.AddJsonFile("appSettings.json", optional: true)
.AddEnvironmentVariables();
var config = builder.Build();
ConfigurationBinder.Bind(config, settings);
services.Configure <EnvironmentSettings>(options => Configuration.GetSection("EnviromentSettings").Bind(options));
return(settings);
});
services.AddDbContext <IngaiaInterviewDbContext>(options =>
options.UseNpgsql(ConvertUrlConnectionString(Configuration.GetValue <string>("DATABASE_URL"))));
services.AddMvc(options => options.Filters.Add(typeof(ExceptionsFilterAttribute)))
.AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining <GetPlaylistForCityQueryValidator>());
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Ingaia Interview", Version = "v1"
});
});
}
private void OnClick_NugetFeedManager(object sender, RoutedEventArgs e)
{
string appDataPath = new EnvironmentSettings().GetEnvironmentVariablePath();
string appSettingsDirPath = Directory.GetParent(appDataPath).FullName;
var appSettings = new ApplicationSettings().GetOrCreateApplicationSettings(appSettingsDirPath);
var packageSourcesDT = appSettings.ClientSettings.PackageSourceDT;
NugetFeedManager nugetFeedManager = new NugetFeedManager(packageSourcesDT);
nugetFeedManager.Owner = this;
nugetFeedManager.ShowDialog();
if (nugetFeedManager.isDataUpdated)
{
appSettings.ClientSettings.PackageSourceDT = nugetFeedManager.GetPackageSourcesData();
appSettings.Save(appSettings, appSettingsDirPath);
}
}
/// <summary>
/// Sets up the configuration based on arguments passed in, config file, and environment
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="config">The configuration.</param>
/// <param name="container">The container.</param>
/// <param name="license">The license.</param>
/// <param name="notifyWarnLoggingAction">Notify warn logging action</param>
public static void set_up_configuration(IList <string> args, ChocolateyConfiguration config, Container container, ChocolateyLicense license, Action <string> notifyWarnLoggingAction)
{
var fileSystem = container.GetInstance <IFileSystem>();
var xmlService = container.GetInstance <IXmlService>();
var configFileSettings = get_config_file_settings(fileSystem, xmlService);
// must be done prior to setting the file configuration
add_or_remove_licensed_source(license, configFileSettings);
set_file_configuration(config, configFileSettings, fileSystem, notifyWarnLoggingAction);
ConfigurationOptions.reset_options();
set_global_options(args, config, container);
set_environment_options(config);
EnvironmentSettings.set_environment_variables(config);
// must be done last for overrides
set_licensed_options(config, license, configFileSettings);
// save all changes if there are any
set_config_file_settings(configFileSettings, xmlService, config);
set_hash_provider(config, container);
}
public void UpdateSysSetting(SysSettingsOptions opts, EnvironmentSettings settings = null)
{
try {
string requestData = string.Empty;
if (opts.Type.Contains("Text"))
{
//Enclosed opts.Value in "", otherwise update fails for all text settings
requestData = "{\"isPersonal\":false,\"sysSettingsValues\":{" + string.Format("\"{0}\":\"{1}\"", opts.Code, opts.Value) + "}}";
}
else
{
requestData = "{\"isPersonal\":false,\"sysSettingsValues\":{" + string.Format("\"{0}\":{1}", opts.Code, opts.Value) + "}}";
}
ApplicationClient.ExecutePostRequest(PostSysSettingsValuesUrl, requestData);
Console.WriteLine("SysSettings with code: {0} updated.", opts.Code);
} catch {
Console.WriteLine("SysSettings with code: {0} is not updated.", opts.Code);
}
}
public void AnalysisResultGetTest()
{
var commonResults = new CommonInputParameterViewModel
{
FileName = Path.Combine(EnvironmentSettings.GetInstance().DataUploadPath, CsvFileName)
};
var analysisParameters = new OutputParametersViewModel()
{
CommonResults = commonResults,
NightWatchmanResults = new NightWatchmanAnalysisResultsViewModel(),
ShoppingResults = new ShoppingAnalysisViewModel()
};
var result = new SavingsAnalysisController().AnalysisResults(analysisParameters) as ViewResult;
Assert.AreEqual(Path.Combine(EnvironmentSettings.GetInstance().DataUploadPath, CsvFileName), result.ViewBag.SelectedFile);
}
public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
{
if (Settings == null)
{
return;
}
float GlobalWindInfluence = Settings.GetFloatPropertyValue("MtreeGlobalWindInfluence");
material.SetFloat("_GlobalWindInfluence", GlobalWindInfluence);
float aoStrength = Settings.GetFloatPropertyValue("AmbientOcclusion");
material.SetFloat("_OcclusionStrength", aoStrength);
if (material.shader.name == "Mtree/Bark")
{
Color barkTintColor = Settings.GetColorPropertyValue("BarkTintColor");
material.SetColor("_Color", barkTintColor);
}
if (material.shader.name == "Mtree/Leafs")
{
Color foliageTintColor = Settings.GetColorPropertyValue("FoliageTintColor");
material.SetColor("_Color", foliageTintColor);
float foliageCutoff = Settings.GetFloatPropertyValue("MtreeCutoff");
material.SetFloat("_Cutoff", foliageCutoff);
float translucentStrength = Settings.GetFloatPropertyValue("TranslucentStrength");
material.SetFloat("_Translucency", translucentStrength);
float TransNormalDistortion = Settings.GetFloatPropertyValue("TransnormalDistortion");
material.SetFloat("_TransNormalDistortion", TransNormalDistortion);
float TransScattering = Settings.GetFloatPropertyValue("TransScattering");
material.SetFloat("_TransScattering", TransScattering);
Color translucentColor = Settings.GetColorPropertyValue("TranslucentColor");
material.SetColor("_TranslucencyTint", translucentColor);
float GlobalWindTurbulence = Settings.GetFloatPropertyValue("MtreeGlobalWindTurbulence");
material.SetFloat("_GlobalTurbulenceInfluence", GlobalWindTurbulence);
}
}
public DriverSession(IDecoratedWebDriver webDriver, EnvironmentSettings environmentSettings, ILogger logger, IControlSettings controlSettings)
{
if (webDriver == null)
{
throw new System.ArgumentNullException(nameof(webDriver));
}
if (environmentSettings == null)
{
throw new System.ArgumentNullException(nameof(environmentSettings));
}
if (controlSettings == null)
{
throw new System.ArgumentNullException(nameof(controlSettings));
}
WebDriver = webDriver;
EnvironmentSettings = environmentSettings;
ControlSettings = controlSettings;
Waiter = new Waiter(webDriver, logger, controlSettings);
}
/// <summary>
/// Sets up the configuration based on arguments passed in, config file, and environment
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="config">The configuration.</param>
/// <param name="container">The container.</param>
/// <param name="license">The license.</param>
/// <param name="notifyWarnLoggingAction">Notify warn logging action</param>
/// <returns>false if command line argument was incorrect, true if succeeded</returns>
public static bool set_up_configuration(IList <string> args, ChocolateyConfiguration config, Container container, Action <string> notifyWarnLoggingAction)
{
var fileSystem = container.GetInstance <IFileSystem>();
var xmlService = container.GetInstance <IXmlService>();
var configFileSettings = get_config_file_settings(fileSystem, xmlService);
set_file_configuration(config, configFileSettings, fileSystem, notifyWarnLoggingAction);
ChocolateyOptionSet.Instance.Clear();
if (ChocolateyOptionSet.Instance.Parse(args, new ChocolateyMainCommand(), config))
{
return(false);
}
set_environment_options(config);
EnvironmentSettings.set_environment_variables(config);
// save all changes if there are any
set_config_file_settings(configFileSettings, xmlService, config);
set_hash_provider(config, container);
return(true);
}
public void UpdateMaterial(Material material, EnvironmentSettings environmentSettings)
{
if (Settings == null)
{
return;
}
if (material.shader.name == "Mtree/Bark")
{
Color barkTintColor = Settings.GetColorPropertyValue("BarkTintColor");
material.SetColor("_Color", barkTintColor);
}
if (material.shader.name == "Mtree/Leafs")
{
Color foliageTintColor = Settings.GetColorPropertyValue("FoliageTintColor");
Color foliageTranslucencyColor = Settings.GetColorPropertyValue("FoliageTranslucencyColor");
material.SetColor("_Color", foliageTintColor);
material.SetColor("_TranslucencyColor", foliageTranslucencyColor);
material.SetFloat("_Cutoff", material.GetFloat("_Cutoff"));
}
}
public static UserInfo RefreshToken(IAutomationEngineInstance engine)
{
var sessionVariablesDict = engine.EngineContext.SessionVariables;
UserInfo userInfo = (UserInfo)sessionVariablesDict["UserInfo"];
sessionVariablesDict.Remove("UserInfo");
//use refresh token and get new auth/refresh tokens
var environmentSettings = new EnvironmentSettings();
environmentSettings.Load();
AuthMethods authMethods = new AuthMethods();
authMethods.Initialize(environmentSettings.ServerType, environmentSettings.OrganizationName, environmentSettings.ServerUrl, environmentSettings.Username, environmentSettings.Password, environmentSettings.AgentId);
authMethods.RefreshToken(userInfo);
return(userInfo);
}
public static async Task <IAppSettings> CreateAsync()
{
IAppSettings settings = default;
await Task.Run(() =>
{
if (SettingsFactory.IsDocker)
{
settings = new EnvironmentSettings();
}
else
{
LocalSettings localSettings = new LocalSettings();
localSettings.LoadSettings();
settings = localSettings;
}
});
return(settings);
}
public void ConfigRenderTests()
{
var Config = new Configuration();
var DefaultSettings = new EnvironmentSettings();
DefaultSettings.Environment = "Default";
DefaultSettings.Settings.Add("Key1", "Value1");
DefaultSettings.Settings.Add("Key2", 2);
DefaultSettings.Settings.Add("Key3", 3.1);
DefaultSettings.Settings.Add("Key4", false);
DefaultSettings.Settings.Add("Key5", DateTime.Now);
Config.DefaultSettings = DefaultSettings;
var DevSettings = new EnvironmentSettings();
DevSettings.Environment = "Local";
DevSettings.Host.Add("NSWIN10VM");
DevSettings.Host.Add("*localhost:*");
DevSettings.Settings.Add("Key1", "LOCALValue1");
DevSettings.Settings.Add("Key2", 102);
Config.Environments.Add(DevSettings.Environment, DevSettings);
var ProdSettings = new EnvironmentSettings();
ProdSettings.Environment = "Prod";
ProdSettings.Host.Add("Ezprod.com");
ProdSettings.Settings.Add("Key1", "PRODValue1");
ProdSettings.Settings.Add("Key2", 902);
ProdSettings.Settings.Add("Key5", DateTime.Now.AddDays(10));
Config.Environments.Add(ProdSettings.Environment, ProdSettings);
var json = JsonConvert.SerializeObject(
Config
, Newtonsoft.Json.Formatting.Indented);
var newConfig = JsonConvert.DeserializeObject <Configuration>(json);
Assert.IsTrue(Config["Key1"].Equals("Value1"), "Key should have equaled Val1");
Config.Url = "http://localhost:50000";
Assert.IsTrue(Config["Key1"].Equals("LOCALValue1"), "Key should have equaled LOCALValue1");
Config.HostName = "SIM-SVR03";
Assert.IsTrue(Config["Key1"].Equals("PRODValue1"), "Key should have equaled PRODValue1");
Config.HostName = "NSWIN10VM";
Assert.IsTrue(Config["Key1"].Equals("LOCALValue1"), "Key should have equaled LOCALValue1");
}
public InstallDNXCommand(EnvironmentSettings settings, DNXSettings dnxsettings)
{
this.settings = settings;
this.dnxsettings = dnxsettings;
}
public void Setup() {
envSettings = new EnvironmentSettings();
ProjectsInfo productInfo = new ProjectsInfo(new System.Xml.XmlDocument(), null);
factory = new CommandFactory(envSettings, productInfo);
}
InstallPackageCommand(EnvironmentSettings settings) {
this.settings = settings;
}
public DownloadDNVMCommand(EnvironmentSettings settings)
{
this.settings = settings;
}
private Settings(AuthSettings auth, EnvironmentSettings environment)
{
Auth = auth;
Environment = environment;
}
public InstallPackageCommand(EnvironmentSettings settings, string pathToPackage)
: this(settings) {
this.settings = settings;
this.pathToPackage = pathToPackage;
}
public InstallPackageCommand(EnvironmentSettings settings, CoreClrProject project)
{
this.settings = settings;
this.project = project;
}
public BuildCommand(EnvironmentSettings settings, CoreClrProject project)
{
this.settings = settings;
this.project = project;
}
public GetFromVCSCommand(EnvironmentSettings settings, string remotePath, string workingDir) :
this(settings, remotePath, string.Empty, string.Empty, workingDir)
{ }
