private void EditCurrentCoin(Coin currentConfiguration) { PoolGroup workingCoin = new PoolGroup(); ObjectCopier.CopyObject(currentConfiguration.PoolGroup, workingCoin); using (CoinEditForm coinEditForm = new CoinEditForm(workingCoin)) { DialogResult dialogResult = coinEditForm.ShowDialog(); if (dialogResult == DialogResult.OK) { Coin existingConfiguration = configurations.SingleOrDefault(c => (c != currentConfiguration) && c.PoolGroup.Id.Equals(workingCoin.Id, StringComparison.OrdinalIgnoreCase)); if (existingConfiguration == null) { ObjectCopier.CopyObject(workingCoin, currentConfiguration.PoolGroup); coinListBox.Items[coinListBox.SelectedIndex] = workingCoin.Name; } else { //don't create a dupe MessageBox.Show(String.Format("A configuration for {0} already exists.", workingCoin.Id), "Duplicate Configuration", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } }
private void saveButton_Click(object sender, EventArgs e) { SaveSettings(); ObjectCopier.CopyObject(workingMinerConfiguration, minerConfiguration); ObjectCopier.CopyObject(workingApplicationConfiguration, applicationConfiguration); DialogResult = System.Windows.Forms.DialogResult.OK; }
private void saveButton_Click(object sender, EventArgs e) { ObjectCopier.CopyObject(workingApplicationConfiguration, applicationConfiguration); applicationConfiguration.StrategyCheckInterval = (Application.TimerInterval)intervalCombo.SelectedIndex; switch (suggestionsCombo.SelectedIndex) { case 1: applicationConfiguration.SuggestCoinsToMine = true; applicationConfiguration.SuggestionsAlgorithm = Engine.Data.CoinSuggestionsAlgorithm.SHA256; break; case 2: applicationConfiguration.SuggestCoinsToMine = true; applicationConfiguration.SuggestionsAlgorithm = Engine.Data.CoinSuggestionsAlgorithm.Scrypt; break; case 3: applicationConfiguration.SuggestCoinsToMine = true; applicationConfiguration.SuggestionsAlgorithm = Engine.Data.CoinSuggestionsAlgorithm.SHA256 | Engine.Data.CoinSuggestionsAlgorithm.Scrypt; break; default: applicationConfiguration.SuggestCoinsToMine = false; break; } DialogResult = System.Windows.Forms.DialogResult.OK; }
private void EditCurrentCoin() { if (coinListBox.SelectedIndex == -1) { return; } Engine.Data.Configuration.Coin currentConfiguration = configurations[coinListBox.SelectedIndex]; CryptoCoin workingCoin = new CryptoCoin(); ObjectCopier.CopyObject(currentConfiguration.CryptoCoin, workingCoin); using (CoinEditForm coinEditForm = new CoinEditForm(workingCoin)) { DialogResult dialogResult = coinEditForm.ShowDialog(); if (dialogResult == System.Windows.Forms.DialogResult.OK) { if (configurations.SingleOrDefault(c => c.CryptoCoin.Symbol.Equals(workingCoin.Symbol, StringComparison.OrdinalIgnoreCase)) == null) { ObjectCopier.CopyObject(workingCoin, currentConfiguration.CryptoCoin); coinListBox.Items[coinListBox.SelectedIndex] = workingCoin.Name; } else { //don't create a dupe MessageBox.Show(String.Format("A configuration for {0} already exists.", workingCoin.Symbol), "Duplicate Configuration", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } }
public void LoadPerksConfiguration(string configDirectory) { InitializeConfigDirectory(configDirectory); Perks tmp = ConfigurationReaderWriter.ReadConfiguration <Perks>(PerksConfigurationFileName()); ObjectCopier.CopyObject(tmp, this); }
public void LoadApplicationConfiguration(string configDirectory) { InitializeConfigDirectory(configDirectory); Application tmp = ConfigurationReaderWriter.ReadConfiguration <Application>(ApplicationConfigurationFileName()); ObjectCopier.CopyObject(tmp, this); }
private static void ApplyCoinInformationToViewModel(List <CoinInformation> coinInformationModels, string coinSymbol, DeviceViewModel deviceViewModel) { CoinInformation coinInformationModel = coinInformationModels.SingleOrDefault(c => c.Symbol.Equals(coinSymbol, StringComparison.OrdinalIgnoreCase)); if (coinInformationModel != null) { ObjectCopier.CopyObject(coinInformationModel, deviceViewModel, "Name", "Exchange"); } }
public static Remoting.Data.Transfer.Configuration.Application ToTransferObject(this Data.Configuration.Application modelObject) { Remoting.Data.Transfer.Configuration.Application transferObject = new Remoting.Data.Transfer.Configuration.Application(); ObjectCopier.CopyObject(modelObject, transferObject, "HiddenColumns"); transferObject.HiddenColumns = modelObject.HiddenColumns.ToArray(); return(transferObject); }
public static Data.Configuration.Application ToModelObject(this Remoting.Data.Transfer.Configuration.Application transferObject) { Data.Configuration.Application modelObject = new Data.Configuration.Application(); ObjectCopier.CopyObject(transferObject, modelObject, "HiddenColumns"); modelObject.HiddenColumns = transferObject.HiddenColumns.ToList(); return(modelObject); }
private Engine.Data.Configuration.Coin AddCoinConfiguration(PoolGroup poolGroup) { //don't allow two configurations for the same coin symbol Engine.Data.Configuration.Coin configuration = configurations.SingleOrDefault(c => c.PoolGroup.Id.Equals(poolGroup.Id, StringComparison.OrdinalIgnoreCase)); if (configuration == null) { //don't allow two configurations for the same coin name configuration = configurations.SingleOrDefault(c => c.PoolGroup.Name.Equals(poolGroup.Name, StringComparison.OrdinalIgnoreCase)); } if (configuration != null) { coinListBox.SelectedIndex = configurations.IndexOf(configuration); } else { configuration = new Engine.Data.Configuration.Coin(); configuration.PoolGroup = knownCoins.SingleOrDefault(c => c.Id.Equals(poolGroup.Id, StringComparison.OrdinalIgnoreCase)); //user may have manually entered a coin or may be using a Multipool if (configuration.PoolGroup == null) { configuration.PoolGroup = new PoolGroup(); ObjectCopier.CopyObject(poolGroup, configuration.PoolGroup); } //at this point, configuration.CryptoCoin.Algorithm MAY be the CoinAlgorithm.FullName //that is how data from Coin API is stored //but coin configurations are based on CoinAlgorithm.Name CoinAlgorithm algorithm = MinerFactory.Instance.Algorithms.SingleOrDefault(a => a.FullName.Equals(configuration.PoolGroup.Algorithm, StringComparison.OrdinalIgnoreCase)); if (algorithm != null) { configuration.PoolGroup.Algorithm = algorithm.Name; } MiningPool miningPool = new MiningPool() { Host = UX.Data.Configuration.PoolDefaults.HostPrefix, Port = UX.Data.Configuration.PoolDefaults.Port }; configuration.Pools.Add(miningPool); configurations.Add(configuration); coinListBox.Items.Add(configuration.PoolGroup.Name); coinListBox.SelectedIndex = configurations.IndexOf(configuration); } hostEdit.Focus(); hostEdit.SelectionStart = hostEdit.SelectionLength; return(configuration); }
private static List <CoinInformation> CopyCoinInformation(List <CoinInformation> coinInformation) { List <CoinInformation> coinInformationCopy = new List <CoinInformation>(); foreach (CoinInformation realCoin in coinInformation) { CoinInformation coinCopy = new CoinInformation(); ObjectCopier.CopyObject(realCoin, coinCopy); coinInformationCopy.Add(coinCopy); } return(coinInformationCopy); }
private void saveButton_Click(object sender, EventArgs e) { CopyLogFilesIfChanged(); //don't persist default values ClearDefaultValues(); ObjectCopier.CopyObject(workingPathConfiguration, pathConfiguration); ObjectCopier.CopyObject(workingApplicationConfiguration, applicationConfiguration); DialogResult = System.Windows.Forms.DialogResult.OK; }
public void LoadMinerConfiguration() { Xgminer minerConfiguration = ConfigurationReaderWriter.ReadConfiguration <Xgminer>(XgminerConfigurationFileName()); ObjectCopier.CopyObject(minerConfiguration, this); UpgradeConfiguration(); if (StratumProxies.Count == 0) { AddDefaultProxy(); } }
public static Engine.Data.Configuration.Engine ToModelObject(this Remoting.Data.Transfer.Configuration.Engine transferObject) { Engine.Data.Configuration.Engine modelObject = new Engine.Data.Configuration.Engine(); ObjectCopier.CopyObject(transferObject, modelObject, "DeviceConfigurations", "XgminerConfiguration", "CoinConfigurations"); modelObject.DeviceConfigurations = transferObject.DeviceConfigurations.ToList().ToModelObjects(); modelObject.XgminerConfiguration = transferObject.XgminerConfiguration.ToModelObject(); modelObject.CoinConfigurations = transferObject.CoinConfigurations.ToList(); return(modelObject); }
public static Remoting.Data.Transfer.Configuration.Engine ToTransferObject(this Engine.Data.Configuration.Engine modelObject) { Remoting.Data.Transfer.Configuration.Engine transferObject = new Remoting.Data.Transfer.Configuration.Engine(); ObjectCopier.CopyObject(modelObject, transferObject, "DeviceConfigurations", "XgminerConfiguration", "CoinConfigurations"); transferObject.DeviceConfigurations = modelObject.DeviceConfigurations.ToTransferObjects().ToArray(); transferObject.XgminerConfiguration = modelObject.XgminerConfiguration.ToTransferObject(); transferObject.CoinConfigurations = modelObject.CoinConfigurations.ToArray(); return(transferObject); }
public DeviceViewModel ApplyDeviceInformationResponseModel(DeviceDescriptor deviceModel, DeviceInformation deviceInformationResponseModel) { string[] excludedProperties = { "Name", //don't overwrite our "nice" name "Kind", //we have our own enum Kind "Enabled" //don't overwrite our own Enabled flag }; DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel)); if (deviceViewModel != null) { if ((deviceModel.Kind == DeviceKind.PXY) || (deviceModel.Kind == DeviceKind.NET)) { deviceViewModel.PoolIndex = deviceInformationResponseModel.PoolIndex; //we will get multiple deviceInformationResponseModels for the same deviceModel in the case of a Stratum Proxy //bfgminer will report back for each Proxy Worker, but we only show a single entry in the ViewModel that rolls //up the stats for individual Proxy Workers deviceViewModel.AverageHashrate += deviceInformationResponseModel.AverageHashrate; deviceViewModel.CurrentHashrate += deviceInformationResponseModel.CurrentHashrate; deviceViewModel.AcceptedShares += deviceInformationResponseModel.AcceptedShares; deviceViewModel.RejectedShares += deviceInformationResponseModel.RejectedShares; deviceViewModel.HardwareErrors += deviceInformationResponseModel.HardwareErrors; deviceViewModel.Utility += deviceInformationResponseModel.Utility; deviceViewModel.WorkUtility += deviceInformationResponseModel.WorkUtility; //now add as a worker DeviceViewModel workerViewModel = new DeviceViewModel(); ObjectCopier.CopyObject(deviceInformationResponseModel, workerViewModel, excludedProperties); workerViewModel.WorkerName = deviceInformationResponseModel.Name; //set a default until (if) we get details deviceViewModel.Workers.Add(workerViewModel); UpdateTemperaturesBasedOnWorkers(deviceViewModel); //recalculate hardware and rejected share percentages - need to be weighted with worker hashrates UpdatePercentagesBasedOnWorkers(deviceViewModel); } else { ObjectCopier.CopyObject(deviceInformationResponseModel, deviceViewModel, excludedProperties); } } return(deviceViewModel); }
public static Remoting.Data.Transfer.Configuration.Engine ToTransferObject(this Engine.Data.Configuration.Engine modelObject) { Remoting.Data.Transfer.Configuration.Engine transferObject = new Remoting.Data.Transfer.Configuration.Engine(); ObjectCopier.CopyObject(modelObject, transferObject, "DeviceConfigurations", "XgminerConfiguration", "CoinConfigurations"); transferObject.DeviceConfigurations = modelObject.DeviceConfigurations.ToTransferObjects().ToArray(); ObjectCopier.CopyObject(modelObject.XgminerConfiguration, transferObject.XgminerConfiguration, "AlgorithmFlags"); foreach (KeyValuePair <CoinAlgorithm, string> pair in modelObject.XgminerConfiguration.AlgorithmFlags) { transferObject.XgminerConfiguration.AlgorithmFlags.Add(pair.Key, pair.Value); } transferObject.CoinConfigurations = modelObject.CoinConfigurations.ToArray(); return(transferObject); }
public static Engine.Data.Configuration.Engine ToModelObject(this Remoting.Data.Transfer.Configuration.Engine transferObject) { Engine.Data.Configuration.Engine modelObject = new Engine.Data.Configuration.Engine(); ObjectCopier.CopyObject(transferObject, modelObject, "DeviceConfigurations", "XgminerConfiguration", "CoinConfigurations"); modelObject.DeviceConfigurations = transferObject.DeviceConfigurations.ToList().ToModelObjects(); ObjectCopier.CopyObject(transferObject.XgminerConfiguration, modelObject.XgminerConfiguration, "AlgorithmFlags"); foreach (CoinAlgorithm key in transferObject.XgminerConfiguration.AlgorithmFlags.Keys) { modelObject.XgminerConfiguration.AlgorithmFlags.Add(key, (string)transferObject.XgminerConfiguration.AlgorithmFlags[key]); } modelObject.CoinConfigurations = transferObject.CoinConfigurations.ToList(); return(modelObject); }
private void copyCoinButton_Click(object sender, EventArgs e) { CoinChooseForm coinChooseForm = new CoinChooseForm(knownCoins); DialogResult dialogResult = coinChooseForm.ShowDialog(); if (dialogResult == System.Windows.Forms.DialogResult.OK) { PoolGroup destinationCoin = coinChooseForm.SelectedCoin; Engine.Data.Configuration.Coin sourceConfiguration = configurations[coinListBox.SelectedIndex]; MultiMiner.Engine.Data.Configuration.Coin destinationConfiguration = AddCoinConfiguration(destinationCoin); ObjectCopier.CopyObject(sourceConfiguration, destinationConfiguration, "CryptoCoin"); BindToCurrentConfiguration(); coinConfigurationBindingSource.ResetBindings(false); miningPoolBindingSource.ResetBindings(false); } }
public void ObjectCopier_SameClasses_Succeeds() { ClassA objA = new ClassA { PropertyA = "1", PropertyB = 1, PropertyC = true, PropertyD = DateTime.UtcNow, PropertyE = EnumA.B }; ClassA objB = new ClassA(); ObjectCopier.CopyObject(objA, objB); Assert.IsTrue(objB.PropertyA.Equals(objA.PropertyA)); Assert.IsTrue(objB.PropertyB.Equals(objA.PropertyB)); Assert.IsTrue(objB.PropertyC.Equals(objA.PropertyC)); Assert.IsTrue(objB.PropertyD.Equals(objA.PropertyD)); Assert.IsTrue(objB.PropertyE.Equals(objA.PropertyE)); }
public static Engine.Data.Configuration.Xgminer ToModelObject(this Remoting.Data.Transfer.Configuration.Xgminer transferObject) { Engine.Data.Configuration.Xgminer modelObject = new Engine.Data.Configuration.Xgminer(); ObjectCopier.CopyObject(transferObject, modelObject, "AlgorithmFlags", "StratumProxies", "AlgorithmMiners"); foreach (CoinAlgorithm key in transferObject.AlgorithmFlags.Keys) { modelObject.AlgorithmFlags.Add(key, (string)transferObject.AlgorithmFlags[key]); } foreach (CoinAlgorithm key in transferObject.AlgorithmMiners.Keys) { modelObject.AlgorithmMiners.Add(key, (string)transferObject.AlgorithmMiners[key]); } modelObject.StratumProxies = transferObject.StratumProxies.ToList(); return(modelObject); }
public static Remoting.Data.Transfer.Configuration.Xgminer ToTransferObject(this Engine.Data.Configuration.Xgminer modelObject) { Remoting.Data.Transfer.Configuration.Xgminer transferObject = new Remoting.Data.Transfer.Configuration.Xgminer(); ObjectCopier.CopyObject(modelObject, transferObject, "AlgorithmFlags", "StratumProxies", "AlgorithmMiners"); foreach (KeyValuePair <CoinAlgorithm, string> pair in modelObject.AlgorithmFlags) { transferObject.AlgorithmFlags.Add(pair.Key, pair.Value); } foreach (KeyValuePair <CoinAlgorithm, string> pair in modelObject.AlgorithmMiners) { transferObject.AlgorithmMiners.Add(pair.Key, pair.Value); } transferObject.StratumProxies = modelObject.StratumProxies.ToArray(); return(transferObject); }
private static void RegisterCustomAlgorithms() { string dataFilePath = AlgorithmConfigurationsFileName(); List <CoinAlgorithm> existingAlgorithms = MinerFactory.Instance.Algorithms; if (File.Exists(dataFilePath)) { List <CoinAlgorithm> customAlgorithms = ConfigurationReaderWriter.ReadConfiguration <List <CoinAlgorithm> >(dataFilePath); foreach (CoinAlgorithm customAlgorithm in customAlgorithms) { CoinAlgorithm existingAlgorithm = existingAlgorithms.SingleOrDefault(ea => ea.Name.Equals(customAlgorithm.Name, StringComparison.OrdinalIgnoreCase)); if (existingAlgorithm != null) { //don't override our Family - user may have added an algo before we support it //don't override BuiltIn - user may have added an algo before we support it ObjectCopier.CopyObject(customAlgorithm, existingAlgorithm, "Family", "BuiltIn"); } else { existingAlgorithms.Add(customAlgorithm); } } } }
public void ApplyDeviceModels(List <Xgminer.Data.Device> deviceModels, List <NetworkDevices.NetworkDevice> networkDeviceModels, List <Metadata.DeviceMetadata> deviceMetadata) { //add/update Devices from deviceModels if (deviceModels != null) { foreach (Xgminer.Data.Device deviceModel in deviceModels) { DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel)); if (deviceViewModel == null) { deviceViewModel = new DeviceViewModel(); Devices.Add(deviceViewModel); } ObjectCopier.CopyObject(deviceModel, deviceViewModel); deviceViewModel.Visible = true; } } //add/update Devices from networkDeviceModels if (networkDeviceModels != null) { foreach (NetworkDevices.NetworkDevice networkDeviceModel in networkDeviceModels) { DeviceViewModel deviceViewModel = networkDeviceModel.ToViewModel(); if (Devices.SingleOrDefault(d => d.Equals(deviceViewModel)) == null) { //set Visible to false until we have details deviceViewModel.Visible = false; //network devices always enabled deviceViewModel.Enabled = true; //assume BTC until we have pool info deviceViewModel.Coin = new CryptoCoin() { Name = KnownCoins.BitcoinName, Symbol = KnownCoins.BitcoinSymbol, Algorithm = CoinAlgorithm.SHA256 }; Devices.Add(deviceViewModel); } } } //apply metadata ASAP for MobileMiner foreach (Metadata.DeviceMetadata metadata in deviceMetadata) { DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(metadata)); if (deviceViewModel != null) { ObjectCopier.CopyObject(metadata, deviceViewModel); } } //remove entries from Devices not found in deviceModels or networkDeviceModels foreach (DeviceViewModel deviceViewModel in Devices.ToList()) { bool found = true; if (deviceViewModel.Kind == DeviceKind.NET) { found = networkDeviceModels.Any(d => d.ToViewModel().Equals(deviceViewModel)); } else { found = deviceModels.Any(d => d.Equals(deviceViewModel)); } if (!found) { Devices.Remove(deviceViewModel); } } }
public void ApplyDeviceModels(List <Xgminer.Data.Device> deviceModels, List <NetworkDevices.NetworkDevice> networkDeviceModels, List <Metadata.DeviceMetadata> deviceMetadata) { //add/update Devices from deviceModels if (deviceModels != null) { foreach (Xgminer.Data.Device deviceModel in deviceModels) { DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(deviceModel)); if (deviceViewModel == null) { deviceViewModel = new DeviceViewModel(); Devices.Add(deviceViewModel); } ObjectCopier.CopyObject(deviceModel, deviceViewModel); deviceViewModel.Visible = true; } } //add/update Devices from networkDeviceModels if (networkDeviceModels != null) { foreach (NetworkDevices.NetworkDevice networkDeviceModel in networkDeviceModels) { DeviceViewModel deviceViewModel = networkDeviceModel.ToViewModel(); if (Devices.SingleOrDefault(d => d.Equals(deviceViewModel)) == null) { deviceViewModel.Visible = false; Devices.Add(deviceViewModel); } } } //remove entries from Devices not found in deviceModels or networkDeviceModels foreach (DeviceViewModel deviceViewModel in Devices.ToList()) { bool found = true; if (deviceViewModel.Kind == DeviceKind.NET) { found = networkDeviceModels.Any(d => d.ToViewModel().Equals(deviceViewModel)); } else { found = deviceModels.Any(d => d.Equals(deviceViewModel)); } if (!found) { Devices.Remove(deviceViewModel); } } //apply metadata foreach (Metadata.DeviceMetadata metadata in deviceMetadata) { DeviceViewModel deviceViewModel = Devices.SingleOrDefault(d => d.Equals(metadata)); if (deviceViewModel != null) { ObjectCopier.CopyObject(metadata, deviceViewModel); } } }
public void LoadApplicationConfiguration() { ApplicationConfiguration tmp = ConfigurationReaderWriter.ReadConfiguration <ApplicationConfiguration>(ApplicationConfigurationFileName()); ObjectCopier.CopyObject(tmp, this); }
public void LoadMinerConfiguration() { Xgminer minerConfiguration = ConfigurationReaderWriter.ReadConfiguration <Xgminer>(XgminerConfigurationFileName()); ObjectCopier.CopyObject(minerConfiguration, this); }
public void LoadPerksConfiguration() { PerksConfiguration tmp = ConfigurationReaderWriter.ReadConfiguration <PerksConfiguration>(PerksConfigurationFileName()); ObjectCopier.CopyObject(tmp, this); }
public void LoadPathConfiguration() { Paths tmp = ConfigurationReaderWriter.ReadConfiguration <Paths>(PathConfigurationFileName()); ObjectCopier.CopyObject(tmp, this); }
private void saveButton_Click(object sender, EventArgs e) { ObjectCopier.CopyObject(workingMinerConfiguration, minerConfiguration); ObjectCopier.CopyObject(workingApplicationConfiguration, applicationConfiguration); DialogResult = DialogResult.OK; }