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;
}
