public static RuleRewriter Create(Type type, ISettings settings, Func<SemanticModel> semanticModel)
{
// A dictionary of all recognised constructor parameters.
Dictionary<Type, Func<object>> parameterTypes = new Dictionary<Type, Func<object>>
{
{ typeof(ISettings), () => settings },
{ typeof(SemanticModel), semanticModel },
};
// Get a list of the type's constructors together with the constructor parameters types,
// ordered by number of parameters descending.
var ctors = (from c in type.GetConstructors()
select new
{
ConstructorInfo = c,
Parameters = c.GetParameters()
}).OrderByDescending(x => x.Parameters.Length).ToArray();
// Get the first constructor in which we recognise all parameter types.
var ctor = ctors.FirstOrDefault(x => x.Parameters.All(p => parameterTypes.Keys.Contains(p.ParameterType)));
object[] parameters = ctor.Parameters.Select(x => parameterTypes[x.ParameterType]()).ToArray();
return (RuleRewriter)ctor.ConstructorInfo.Invoke(parameters);
}
protected AbstractHarddrive(ISmart smart, string name,
string firmwareRevision, int index,
IEnumerable<SmartAttribute> smartAttributes, ISettings settings)
: base(name, new Identifier("hdd",
index.ToString(CultureInfo.InvariantCulture)), settings)
{
this.firmwareRevision = firmwareRevision;
this.smart = smart;
handle = smart.OpenDrive(index);
if (handle != smart.InvalidHandle)
smart.EnableSmart(handle, index);
this.index = index;
this.count = 0;
this.smartAttributes = new List<SmartAttribute>(smartAttributes);
string[] logicalDrives = smart.GetLogicalDrives(index);
List<DriveInfo> driveInfoList = new List<DriveInfo>(logicalDrives.Length);
foreach (string logicalDrive in logicalDrives) {
try {
DriveInfo di = new DriveInfo(logicalDrive);
if (di.TotalSize > 0)
driveInfoList.Add(new DriveInfo(logicalDrive));
} catch (ArgumentException) { } catch (IOException) { }
}
driveInfos = driveInfoList.ToArray();
CreateSensors();
}
public Context(ISettings settings, ILogicSettings logicSettings)
{
Settings = settings;
LogicSettings = logicSettings;
Translations = Translations.Load(logicSettings.TranslationLanguageCode);
Reset(settings, LogicSettings);
}
public SSDSandforce(ISmart smart, string name, string firmwareRevision,
int index, ISettings settings)
: base(smart, name, firmwareRevision, index, smartAttributes, settings)
{
this.writeAmplification = new Sensor("Write Amplification", 1,
SensorType.Factor, this, settings);
}
public Adapter(ISettings settings, IServiceFacade udapiServiceFacade, IAdapterPlugin platformConnector, IStreamListenerManager listenersManager)
{
_listenersManager = listenersManager;
Settings = settings;
UDAPIService = udapiServiceFacade;
PlatformConnector = platformConnector;
var statemanager = new StateManager(settings,platformConnector);
StateManager = statemanager;
StateProviderProxy.Init(statemanager);
listenersManager.StateManager = statemanager;
if (settings.StatsEnabled)
StatsManager.Configure();
// we just need the initialisation
new SuspensionManager(statemanager, PlatformConnector);
platformConnector.Initialise();
statemanager.AddRules(platformConnector.MarketRules);
ThreadPool.SetMinThreads(500, 500);
_sports = new List<string>();
_stats = StatsManager.Instance["adapter.core"].GetHandle();
PopuplateAdapterVersionInfo();
}
//
// GET: /Account/Login
public AccountController(IServices services, ISettings settings, IComponents components, IUserStore<ApplicationUser, Guid> userStore)
: base(services, settings)
{
_userManager = new ApplicationUserManager(userStore, services, components);
Mapper.CreateMap<ApplicationUser, UserDto>();
}
public void Reset(ISettings settings, ILogicSettings logicSettings)
{
Client = new Client(Settings);
LogicClient = new LogicClient(LogicSettings);
Inventory = new Inventory(Client, LogicClient);
Navigation = new Navigation(Client);
}
public SingleWebServerApplicationState(ISettings settings, IApplicationBus bus, IDocumentSession docSession, HttpContextBase httpContext)
{
this.settings = settings;
this.bus = bus;
this.docSession = docSession;
this.httpContext = httpContext;
}
public ProjectFactory(Project project)
{
_project = project;
ProjectProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
AddSolutionDir();
_settings = null;
}
protected void Page_Load(object sender, EventArgs e)
{
_logging = IoC.IoC.Get<ILog>();
_date = IoC.IoC.Get<IDate>();
_settings = IoC.IoC.Get<ISettings>();
_emailNotificationItems = IoC.IoC.Get<IEmailNotificationItems>();
_sendEmail = IoC.IoC.Get<IEmail>();
_status = IoC.IoC.Get<IStatus>();
var url = Request.Url.AbsoluteUri;
if (Request.QueryString["csvfile"] == null)
{
numberOfRun += 1;
_logging.Msg("CroneJob startet, " + numberOfRun);
if (DateTime.Now.Hour == 8)
{
_sendEmail.SendEmail("*****@*****.**", "*****@*****.**", "Cronejob startet kl. 8:00, antal gange det er kørt siden sidst: " + numberOfRun, "");
numberOfRun = 0;
}
url = null;
}
Run(url);
}
public Context(ISettings settings, ILogicSettings logicSettings)
{
Settings = settings;
LogicSettings = logicSettings;
Reset(settings, LogicSettings);
}
internal PackageRestoreManager(
DTE dte,
ISolutionManager solutionManager,
IFileSystemProvider fileSystemProvider,
IPackageRepositoryFactory packageRepositoryFactory,
IVsPackageSourceProvider packageSourceProvider,
IVsPackageManagerFactory packageManagerFactory,
IVsPackageInstallerEvents packageInstallerEvents,
IPackageRepository localCacheRepository,
IVsThreadedWaitDialogFactory waitDialogFactory,
ISettings settings)
{
Debug.Assert(solutionManager != null);
_dte = dte;
_fileSystemProvider = fileSystemProvider;
_solutionManager = solutionManager;
_packageRepositoryFactory = packageRepositoryFactory;
_packageSourceProvider = packageSourceProvider;
_waitDialogFactory = waitDialogFactory;
_packageManagerFactory = packageManagerFactory;
_localCacheRepository = localCacheRepository;
_settings = settings;
_solutionManager.ProjectAdded += OnProjectAdded;
_solutionManager.SolutionOpened += OnSolutionOpenedOrClosed;
_solutionManager.SolutionClosed += OnSolutionOpenedOrClosed;
packageInstallerEvents.PackageReferenceAdded += OnPackageReferenceAdded;
}
public FormDeviceConfiguration(ISettings settings)
{
InitializeComponent();
this.settings = settings;
// Init.
this.buttonSave.Enabled = false;
this.textBoxIPAddress.Text = settings.DeviceIPAddress;
this.textBoxIPAddress.SelectionStart = this.textBoxIPAddress.Text.Length; // Don't select text content.
if (settings.PollingType == Core.PollingType.WDTSync) {
this.radioButtonPollingTypeWDTSync.Checked = true;
this.textBoxPollingInterval.Enabled = false;
this.labelPollingIntervalUnits.Enabled = false;
}
else {
this.radioButtonPollingTypeInterval.Checked = true;
}
this.textBoxPollingInterval.Text = String.Format("{0}", settings.PollingInterval);
this.textBoxIPAddress.TextChanged += new EventHandler(textBoxIPAddress_TextChanged);
this.radioButtonPollingTypeWDTSync.CheckedChanged += new EventHandler(radioButtons_CheckedChanged);
this.radioButtonPollingTypeInterval.CheckedChanged += new EventHandler(radioButtons_CheckedChanged);
this.textBoxPollingInterval.TextChanged += new EventHandler(textBoxPollingInterval_TextChanged);
}
internal VsPackageSourceProvider(
ISettings settings,
IPackageSourceProvider packageSourceProvider,
IVsShellInfo vsShellInfo)
:this(settings, packageSourceProvider, vsShellInfo, null)
{
}
private VsPackageSourceProvider(
ISettings settings,
IPackageSourceProvider packageSourceProvider,
IVsShellInfo vsShellInfo,
ISolutionManager solutionManager)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (packageSourceProvider == null)
{
throw new ArgumentNullException("packageSourceProvider");
}
if (vsShellInfo == null)
{
throw new ArgumentNullException("vsShellInfo");
}
_packageSourceProvider = packageSourceProvider;
_solutionManager = solutionManager;
_settings = settings;
_vsShellInfo = vsShellInfo;
if (null != _solutionManager)
{
_solutionManager.SolutionClosed += OnSolutionOpenedOrClosed;
_solutionManager.SolutionOpened += OnSolutionOpenedOrClosed;
}
}
public Sensor(string name, int index, SensorType sensorType,
Hardware hardware, ParameterDescription[] parameterDescriptions,
ISettings settings)
: this(name, index, false, sensorType, hardware,
parameterDescriptions, settings)
{
}
public VsPackageSourceProvider(
ISettings settings,
IVsShellInfo vsShellInfo,
ISolutionManager solutionManager) :
this(settings, new PackageSourceProvider(settings, new[] { NuGetDefaultSource }, _feedsToMigrate), vsShellInfo, solutionManager)
{
}
public Control(ISensor sensor, ISettings settings, float minSoftwareValue,
float maxSoftwareValue)
{
this.identifier = new Identifier(sensor.Identifier, "control");
this.settings = settings;
this.minSoftwareValue = minSoftwareValue;
this.maxSoftwareValue = maxSoftwareValue;
if (!float.TryParse(settings.GetValue(
new Identifier(identifier, "value").ToString(), "0"),
NumberStyles.Float, CultureInfo.InvariantCulture,
out this.softwareValue))
{
this.softwareValue = 0;
}
int mode;
if (!int.TryParse(settings.GetValue(
new Identifier(identifier, "mode").ToString(),
((int)ControlMode.Default).ToString(CultureInfo.InvariantCulture)),
NumberStyles.Integer, CultureInfo.InvariantCulture,
out mode))
{
this.mode = ControlMode.Default;
} else {
this.mode = (ControlMode)mode;
}
}
// TODO: At some point we should try to inject this during view creation, by means of ViewEngineFactory.
// This is not really an issue for ISettings, as this is a singleton, not requiring disposal. (pruiz)
public override void InitHelpers()
{
base.InitHelpers();
Bootstrap = Html.Bootstrap();
Settings = this.GetSettings();
}
public QuadMesh(IHeightfieldGenerator generator, ITerrainColorizer terrainColorizer, IQuadMeshRenderer renderer, ISettings settings)
{
_generator = generator;
_terrainColorizer = terrainColorizer;
_renderer = renderer;
_settings = settings;
}
public Client(ISettings settings)
{
Settings = settings;
Tuple<double, double> latLngFromFile = GetLatLngFromFile();
if (latLngFromFile != null && latLngFromFile.Item1 != 0 && latLngFromFile.Item2 != 0)
{
SetCoordinates(latLngFromFile.Item1, latLngFromFile.Item2, Settings.DefaultAltitude);
}
else
{
if (!File.Exists(lastcoords_file) || !File.ReadAllText(lastcoords_file).Contains(":"))
Logger.Write("Missing \"\\Configs\\LastCoords.ini\", using default settings for coordinates and create a new one...");
SetCoordinates(Settings.DefaultLatitude, Settings.DefaultLongitude, Settings.DefaultAltitude);
}
//Setup HttpClient and create default headers
var handler = new HttpClientHandler
{
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
AllowAutoRedirect = false
};
_httpClient = new HttpClient(new RetryHandler(handler));
_httpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", "Niantic App");
//"Dalvik/2.1.0 (Linux; U; Android 5.1.1; SM-G900F Build/LMY48G)");
_httpClient.DefaultRequestHeaders.ExpectContinue = false;
_httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Connection", "keep-alive");
_httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Accept", "*/*");
_httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type",
"application/x-www-form-urlencoded");
}
protected internal InstallCommand(
IPackageRepositoryFactory packageRepositoryFactory,
IPackageSourceProvider sourceProvider,
ISettings configSettings,
IPackageRepository cacheRepository)
{
if (packageRepositoryFactory == null)
{
throw new ArgumentNullException("packageRepositoryFactory");
}
if (sourceProvider == null)
{
throw new ArgumentNullException("sourceProvider");
}
if (configSettings == null)
{
throw new ArgumentNullException("configSettings");
}
RepositoryFactory = packageRepositoryFactory;
SourceProvider = sourceProvider;
_cacheRepository = cacheRepository;
_configSettings = configSettings;
}
public Hardware(string name, Identifier identifier, ISettings settings) {
this.settings = settings;
this.identifier = identifier;
this.name = name;
this.customName = settings.GetValue(
new Identifier(Identifier, "name").ToString(), name);
}
public void SetUp()
{
Test.SetUp();
settings = ServiceContainer.Resolve<ISettings>();
loginViewModel = new LoginViewModel();
}
public ATIGPU(string name, int adapterIndex, int busNumber, int deviceNumber, ISettings settings)
: base(name, new Identifier("atigpu", adapterIndex.ToString(CultureInfo.InvariantCulture)), settings)
{
this.adapterIndex = adapterIndex;
this.busNumber = busNumber;
this.deviceNumber = deviceNumber;
this.temperature = new Sensor("GPU Core", 0, SensorType.Temperature, this, settings);
this.fan = new Sensor("GPU Fan", 0, SensorType.Fan, this, settings);
this.coreClock = new Sensor("GPU Core", 0, SensorType.Clock, this, settings);
this.memoryClock = new Sensor("GPU Memory", 1, SensorType.Clock, this, settings);
this.coreVoltage = new Sensor("GPU Core", 0, SensorType.Voltage, this, settings);
this.coreLoad = new Sensor("GPU Core", 0, SensorType.Load, this, settings);
this.controlSensor = new Sensor("GPU Fan", 0, SensorType.Control, this, settings);
ADLOD6ThermalControllerCaps adltcc = new ADLOD6ThermalControllerCaps();
if (ADL.ADL_Overdrive6_ThermalController_Caps(adapterIndex, ref adltcc) != ADL.ADL_OK)
{
adltcc.iFanMinPercent = 0;
adltcc.iFanMaxPercent = 100;
}
this.fanControl = new Control(controlSensor, settings, adltcc.iFanMinPercent, adltcc.iFanMaxPercent);
this.fanControl.ControlModeChanged += ControlModeChanged;
this.fanControl.SoftwareControlValueChanged += SoftwareControlValueChanged;
ControlModeChanged(fanControl);
this.controlSensor.Control = fanControl;
Update();
}
public Sensor(string name, int index, bool defaultHidden,
SensorType sensorType, Hardware hardware,
ParameterDescription[] parameterDescriptions, ISettings settings)
{
this.index = index;
this.defaultHidden = defaultHidden;
this.sensorType = sensorType;
this.hardware = hardware;
Parameter[] parameters = new Parameter[parameterDescriptions == null ?
0 : parameterDescriptions.Length];
for (int i = 0; i < parameters.Length; i++ )
parameters[i] = new Parameter(parameterDescriptions[i], this, settings);
this.parameters = parameters;
this.settings = settings;
this.defaultName = name;
this.name = settings.GetValue(
new Identifier(Identifier, "name").ToString(), name);
GetSensorValuesFromSettings();
hardware.Closing += delegate(IHardware h) {
SetSensorValuesToSettings();
};
}
public AccountController(IUser userRepository, ISettings settingsRepository, IRole roleRepository)
: base(settingsRepository)
{
_userRepository = userRepository;
_roleRepository = roleRepository;
ExpectedMasterName = string.Empty;
}
public VsSourceControlTracker(
ISolutionManager solutionManager,
IFileSystemProvider fileSystemProvider,
IVsTrackProjectDocuments2 projectTracker,
ISettings solutionSettings)
{
if (projectTracker == null)
{
throw new ArgumentNullException("projectTracker");
}
_solutionManager = solutionManager;
_projectTracker = projectTracker;
_fileSystemProvider = fileSystemProvider;
_solutionSettings = solutionSettings;
_projectDocumentListener = new TrackProjectDocumentEventListener(this);
_solutionManager.SolutionOpened += OnSolutionOpened;
_solutionManager.SolutionClosed += OnSolutionClosed;
if (_solutionManager.IsSolutionOpen)
{
StartTracking();
}
}
public Logic(ISettings clientSettings)
{
_clientSettings = clientSettings;
_client = new Client(_clientSettings);
_inventory = new Inventory(_client);
_navigation = new Navigation(_client);
}
public FileStorage(ISettings settings)
{
_settings = settings;
_resizeSettings = new ResizeSettings {
MaxWidth = settings.ThumbnailSize,
MaxHeight = settings.ThumbnailSize,
Format = "jpg"
};
_resizeSettings.Add("quality", ImageQuality);
//create FullsizedImagesFolder & SmallImagesFolder subfolders
string largeFilesFolder = Path.Combine(settings.ImagesLocalFolder, FullsizedImagesFolder);
string smallFilesFolder = Path.Combine(settings.ImagesLocalFolder, SmallImagesFolder);
if (!Directory.Exists(largeFilesFolder))
Directory.CreateDirectory(largeFilesFolder);
if (!Directory.Exists(smallFilesFolder))
Directory.CreateDirectory(smallFilesFolder);
_lastPhoto = Directory
.GetFiles(largeFilesFolder, "*.jpg")
.Select(i => int.Parse(Path.GetFileNameWithoutExtension(i).ToLower().Replace(".jpg", "")))
.OrderByDescending(i => i)
.FirstOrDefault();
if (_lastPhoto < 1)
_lastPhoto = 1;
}
public static string BaseAddress(ISettings settings) => BindAddress(settings).Replace("*", "localhost");
public VideoFileScanner(ISettings settings = null)
{
_settings = settings ?? Program.Settings;
}
public static bool RemoteAccessEnabled(ISettings settings) => BindAddress(settings).Contains("://*");
public AppSettings(ISettings settings)
{
_settings = settings;
}
/// <summary>
/// Emulates a JSON deserialization from project.json to PackageSpec in a post-project.json world
/// </summary>
private async Task <PackageSpec> GetPackageSpecAsync(ISettings settings)
{
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var projectReferences = await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(NullLogger.Instance, CancellationToken.None);
var targetFramework = await _vsProjectAdapter.GetTargetFrameworkAsync();
var packageReferences = (await ProjectServices
.ReferencesReader
.GetPackageReferencesAsync(targetFramework, CancellationToken.None))
.ToList();
var packageTargetFallback = MSBuildStringUtility.Split(GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.PackageTargetFallback))
.Select(NuGetFramework.Parse)
.ToList();
var assetTargetFallback = MSBuildStringUtility.Split(GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.AssetTargetFallback))
.Select(NuGetFramework.Parse)
.ToList();
var projectTfi = new TargetFrameworkInformation
{
FrameworkName = targetFramework,
Dependencies = packageReferences,
};
bool isCpvmEnabled = MSBuildStringUtility.IsTrue(GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.ManagePackageVersionsCentrally));
if (isCpvmEnabled)
{
// Add the central version information and merge the information to the package reference dependencies
projectTfi.CentralPackageVersions.AddRange(await GetCentralPackageVersionsAsync());
LibraryDependency.ApplyCentralVersionInformation(projectTfi.Dependencies, projectTfi.CentralPackageVersions);
}
// Apply fallback settings
AssetTargetFallbackUtility.ApplyFramework(projectTfi, packageTargetFallback, assetTargetFallback);
// Build up runtime information.
var runtimes = await _vsProjectAdapter.GetRuntimeIdentifiersAsync();
var supports = await _vsProjectAdapter.GetRuntimeSupportsAsync();
var runtimeGraph = new RuntimeGraph(runtimes, supports);
// In legacy CSProj, we only have one target framework per project
var tfis = new TargetFrameworkInformation[] { projectTfi };
var projectName = ProjectName ?? ProjectUniqueName;
string specifiedPackageId = _vsProjectAdapter.BuildProperties.GetPropertyValue(ProjectBuildProperties.PackageId);
if (!string.IsNullOrWhiteSpace(specifiedPackageId))
{
projectName = specifiedPackageId;
}
else
{
string specifiedAssemblyName = _vsProjectAdapter.BuildProperties.GetPropertyValue(ProjectBuildProperties.AssemblyName);
if (!string.IsNullOrWhiteSpace(specifiedAssemblyName))
{
projectName = specifiedAssemblyName;
}
}
return(new PackageSpec(tfis)
{
Name = projectName,
Version = new NuGetVersion(_vsProjectAdapter.Version),
FilePath = ProjectFullPath,
RuntimeGraph = runtimeGraph,
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectStyle = ProjectStyle.PackageReference,
OutputPath = await GetMSBuildProjectExtensionsPathAsync(),
ProjectPath = ProjectFullPath,
ProjectName = projectName,
ProjectUniqueName = ProjectFullPath,
OriginalTargetFrameworks = tfis
.Select(tfi => tfi.FrameworkName.GetShortFolderName())
.ToList(),
TargetFrameworks = new List <ProjectRestoreMetadataFrameworkInfo>
{
new ProjectRestoreMetadataFrameworkInfo(tfis[0].FrameworkName)
{
ProjectReferences = projectReferences?.ToList()
}
},
SkipContentFileWrite = true,
CacheFilePath = await GetCacheFilePathAsync(),
PackagesPath = GetPackagesPath(settings),
Sources = GetSources(settings),
FallbackFolders = GetFallbackFolders(settings),
ConfigFilePaths = GetConfigFilePaths(settings),
ProjectWideWarningProperties = WarningProperties.GetWarningProperties(
treatWarningsAsErrors: GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.TreatWarningsAsErrors),
noWarn: GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.NoWarn),
warningsAsErrors: GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.WarningsAsErrors)),
RestoreLockProperties = new RestoreLockProperties(
GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.RestorePackagesWithLockFile),
GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.NuGetLockFilePath),
MSBuildStringUtility.IsTrue(GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.RestoreLockedMode))),
CentralPackageVersionsEnabled = isCpvmEnabled,
CentralPackageVersionOverrideDisabled = GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.CentralPackageVersionOverrideEnabled).EqualsFalse(),
CentralPackageTransitivePinningEnabled = MSBuildStringUtility.IsTrue(GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.CentralPackageTransitivePinningEnabled)),
}
});
}
public PublishFunctionAppAction(ISettings settings, ISecretsManager secretsManager)
{
_settings = settings;
_secretsManager = secretsManager;
}
public UnityBuildRunnerBatch(IBuilder builder, ISettings settings)
{
this.builder = builder;
this.settings = settings;
}
public VSPackageRestoreManager(ISourceRepositoryProvider sourceRepositoryProvider, ISettings settings, ISolutionManager solutionManager)
: base(sourceRepositoryProvider, settings, solutionManager)
{
SolutionManager = solutionManager;
SolutionManager.NuGetProjectAdded += OnNuGetProjectAdded;
SolutionManager.SolutionOpened += OnSolutionOpenedOrClosed;
SolutionManager.SolutionClosed += OnSolutionOpenedOrClosed;
}
/// <summary>
/// Returns true if automatic package restore on build is enabled.
/// </summary>
/// <returns>True if automatic package restore on build is enabled.</returns>
private static bool IsAutomatic(ISettings settings)
{
var packageRestoreConsent = new PackageRestoreConsent(settings);
return(packageRestoreConsent.IsAutomatic);
}
/// <summary>
/// Returns true if the package restore user consent is granted.
/// </summary>
/// <returns>True if the package restore user consent is granted.</returns>
private static bool IsConsentGranted(ISettings settings)
{
var packageRestoreConsent = new PackageRestoreConsent(settings);
return(packageRestoreConsent.IsGranted);
}
public PtcLogin(ISettings settings)
{
this.username = settings.PtcUsername;
this.password = settings.PtcPassword;
this._settings = settings;
}
public static string BindAddress(ISettings settings) => $"{settings.Get<string>(HttpServerAddress)}:{settings.Get<int>(HttpServerPort)}";
public SettingsService()
{
settings = CrossSettings.Current;
}
private StorageGeneric(StorageInfo storageInfo, string name, string firmwareRevision, int index, ISettings settings)
: base(storageInfo, name, firmwareRevision, "hdd", index, settings)
{
CreateSensors();
}
/// <summary>
/// Init library with isolated environment
/// </summary>
/// <param name="lib">Path to library</param>
/// <param name="sln">Path to .sln file</param>
/// <param name="properties">Solution properties</param>
/// <param name="cfg">Provider settings</param>
public Library(string lib, string sln, Dictionary <string, string> properties, ISettings cfg)
{
config = cfg;
initLib(prepare(lib));
if (cfg.LibSettings != null)
{
EntryPoint.load(sln, properties, cfg.LibSettings);
}
else
{
EntryPoint.load(sln, properties);
}
}
public Session(ISettings settings, ILogicSettings logicSettings, IElevationService elevationService) : this(
settings, logicSettings, elevationService, Common.Translation.Load(logicSettings))
{
LoggedTime = DateTime.Now;
}
public TestTreeSettings(ISettings settings)
: base(settings, "Gui.TestTree")
{
}
public virtual void OnSetup()
{
this.Settings = this.Create();
this.Settings.Clear();
}
/// <summary>
/// Get entities from adoxio_settings
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='top'>
/// </param>
/// <param name='skip'>
/// </param>
/// <param name='search'>
/// </param>
/// <param name='filter'>
/// </param>
/// <param name='count'>
/// </param>
/// <param name='orderby'>
/// Order items by property values
/// </param>
/// <param name='select'>
/// Select properties to be returned
/// </param>
/// <param name='expand'>
/// Expand related entities
/// </param>
public static SettingsGetResponseModel Get(this ISettings operations, int?top = default(int?), int?skip = default(int?), string search = default(string), string filter = default(string), bool?count = default(bool?), IList <string> orderby = default(IList <string>), IList <string> select = default(IList <string>), IList <string> expand = default(IList <string>))
{
return(operations.GetAsync(top, skip, search, filter, count, orderby, select, expand).GetAwaiter().GetResult());
}
public SSDIntel(ISmart smart, string name, string firmwareRevision,
int index, ISettings settings)
: base(smart, name, firmwareRevision, index, smartAttributes, settings)
{
}
/// <summary>
/// Update entity in adoxio_settings
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='adoxioSettingid'>
/// key: adoxio_settingid
/// </param>
/// <param name='body'>
/// New property values
/// </param>
public static void Update(this ISettings operations, string adoxioSettingid, MicrosoftDynamicsCRMadoxioSetting body)
{
operations.UpdateAsync(adoxioSettingid, body).GetAwaiter().GetResult();
}
/// <summary>
/// Add new entity to adoxio_settings
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// New entity
/// </param>
/// <param name='prefer'>
/// Required in order for the service to return a JSON representation of the
/// object.
/// </param>
public static MicrosoftDynamicsCRMadoxioSetting Create(this ISettings operations, MicrosoftDynamicsCRMadoxioSetting body, string prefer = "return=representation")
{
return(operations.CreateAsync(body, prefer).GetAwaiter().GetResult());
}
/// <summary>
/// Delete entity from adoxio_settings
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='adoxioSettingid'>
/// key: adoxio_settingid
/// </param>
/// <param name='ifMatch'>
/// ETag
/// </param>
public static void Delete(this ISettings operations, string adoxioSettingid, string ifMatch = default(string))
{
operations.DeleteAsync(adoxioSettingid, ifMatch).GetAwaiter().GetResult();
}
/// <summary>
/// Update entity in adoxio_settings
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='adoxioSettingid'>
/// key: adoxio_settingid
/// </param>
/// <param name='body'>
/// New property values
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task UpdateAsync(this ISettings operations, string adoxioSettingid, MicrosoftDynamicsCRMadoxioSetting body, CancellationToken cancellationToken = default(CancellationToken))
{
(await operations.UpdateWithHttpMessagesAsync(adoxioSettingid, body, null, cancellationToken).ConfigureAwait(false)).Dispose();
}
public RssFeedService(ISettings settings)
{
this.settings = settings;
}
/// <summary>
/// Delete entity from adoxio_settings
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='adoxioSettingid'>
/// key: adoxio_settingid
/// </param>
/// <param name='ifMatch'>
/// ETag
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task DeleteAsync(this ISettings operations, string adoxioSettingid, string ifMatch = default(string), CancellationToken cancellationToken = default(CancellationToken))
{
(await operations.DeleteWithHttpMessagesAsync(adoxioSettingid, ifMatch, null, cancellationToken).ConfigureAwait(false)).Dispose();
}
public void Save(ISettings settings, System.IO.Stream stream)
{
var document = new XmlDocument();
XmlNode docNode = document.CreateXmlDeclaration("1.0", "UTF-8", null);
document.AppendChild(docNode);
var parent = document.CreateElement("Settings");
var version = document.CreateAttribute("version");
version.Value = "1.4";
parent.Attributes.Append(version);
document.AppendChild(parent);
var splitKey = document.CreateElement("SplitKey");
if (settings.SplitKey != null)
{
splitKey.InnerText = settings.SplitKey.ToString();
}
parent.AppendChild(splitKey);
var resetKey = document.CreateElement("ResetKey");
if (settings.ResetKey != null)
{
resetKey.InnerText = settings.ResetKey.ToString();
}
parent.AppendChild(resetKey);
var skipKey = document.CreateElement("SkipKey");
if (settings.SkipKey != null)
{
skipKey.InnerText = settings.SkipKey.ToString();
}
parent.AppendChild(skipKey);
var undoKey = document.CreateElement("UndoKey");
if (settings.UndoKey != null)
{
undoKey.InnerText = settings.UndoKey.ToString();
}
parent.AppendChild(undoKey);
var pauseKey = document.CreateElement("PauseKey");
if (settings.PauseKey != null)
{
pauseKey.InnerText = settings.PauseKey.ToString();
}
parent.AppendChild(pauseKey);
var toggleKey = document.CreateElement("ToggleGlobalHotkeys");
if (settings.ToggleGlobalHotkeys != null)
{
toggleKey.InnerText = settings.ToggleGlobalHotkeys.ToString();
}
parent.AppendChild(toggleKey);
var switchComparisonPrevious = document.CreateElement("SwitchComparisonPrevious");
if (settings.SwitchComparisonPrevious != null)
{
switchComparisonPrevious.InnerText = settings.SwitchComparisonPrevious.ToString();
}
parent.AppendChild(switchComparisonPrevious);
var switchComparisonNext = document.CreateElement("SwitchComparisonNext");
if (settings.SwitchComparisonNext != null)
{
switchComparisonNext.InnerText = settings.SwitchComparisonNext.ToString();
}
parent.AppendChild(switchComparisonNext);
parent.AppendChild(ToElement(document, "GlobalHotkeysEnabled", settings.GlobalHotkeysEnabled));
parent.AppendChild(ToElement(document, "DeactivateHotkeysForOtherPrograms", settings.DeactivateHotkeysForOtherPrograms));
parent.AppendChild(ToElement(document, "WarnOnReset", settings.WarnOnReset));
parent.AppendChild(ToElement(document, "DoubleTapPrevention", settings.DoubleTapPrevention));
//parent.AppendChild(ToElement(document, "RefreshRate", settings.RefreshRate));
parent.AppendChild(ToElement(document, "HotkeyDelay", settings.HotkeyDelay));
parent.AppendChild(ToElement(document, "RaceViewer", settings.RaceViewer.Name));
parent.AppendChild(ToElement(document, "AgreedToSRLRules", settings.AgreedToSRLRules));
var recentSplits = document.CreateElement("RecentSplits");
foreach (var splits in settings.RecentSplits)
{
recentSplits.AppendChild(ToElement(document, "SplitsPath", splits));
}
parent.AppendChild(recentSplits);
var recentLayouts = document.CreateElement("RecentLayouts");
foreach (var layout in settings.RecentLayouts)
{
recentLayouts.AppendChild(ToElement(document, "LayoutPath", layout));
}
parent.AppendChild(recentLayouts);
parent.AppendChild(ToElement(document, "LastComparison", settings.LastComparison));
parent.AppendChild(ToElement(document, "LastTimingMethod", settings.LastTimingMethod));
parent.AppendChild(ToElement(document, "SimpleSumOfBest", settings.SimpleSumOfBest));
var autoSplittersActive = document.CreateElement("ActiveAutoSplitters");
foreach (var splitter in settings.ActiveAutoSplitters)
{
autoSplittersActive.AppendChild(ToElement(document, "AutoSplitter", splitter));
}
parent.AppendChild(autoSplittersActive);
document.Save(stream);
}
/// <summary>
/// Get entity from adoxio_settings by key
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='adoxioSettingid'>
/// key: adoxio_settingid
/// </param>
/// <param name='select'>
/// Select properties to be returned
/// </param>
/// <param name='expand'>
/// Expand related entities
/// </param>
public static MicrosoftDynamicsCRMadoxioSetting GetByKey(this ISettings operations, string adoxioSettingid, IList <string> select = default(IList <string>), IList <string> expand = default(IList <string>))
{
return(operations.GetByKeyAsync(adoxioSettingid, select, expand).GetAwaiter().GetResult());
}
private IList <string> GetConfigFilePaths(ISettings settings)
{
return(settings.GetConfigFilePaths());
}
public ModelGenerated(ISettings settings, Module module, Model model)
{
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
_module = module ?? throw new ArgumentNullException(nameof(module));
_model = model ?? throw new ArgumentNullException(nameof(module));
}
