public MainWindowViewModel()
{
if (Design.IsInDesignMode)
{
return;
}
this.CloseMainWindow = new DelegateCommand(() => {
if (MinerProfile.IsNoUi)
{
VirtualRoot.Execute(new CloseMainWindowCommand());
}
else
{
VirtualRoot.Execute(new CloseNTMinerCommand());
}
});
this.CustomTheme = new DelegateCommand(() => {
LogColor.ShowWindow();
});
this.UseThisPcName = new DelegateCommand(() => {
string thisPcName = NTMinerRoot.GetThisPcName();
DialogWindow.ShowDialog(message: $"确定使用本机名{thisPcName}作为矿机名吗？", title: "确认", onYes: () => {
MinerProfile.MinerName = thisPcName;
}, icon: IconConst.IconConfirm);
});
if (DevMode.IsDevMode)
{
_serverJsonVersion = GetServerJsonVersion();
}
}
private void Init()
{
lock (_locker) {
if (!_isInited)
{
var repository = NTMinerRoot.CreateServerRepository <KernelOutputTranslaterData>();
foreach (var item in repository.GetAll())
{
if (!_dicById.ContainsKey(item.GetId()))
{
_dicById.Add(item.GetId(), item);
}
if (!_dicByKernelOutputId.ContainsKey(item.KernelOutputId))
{
_dicByKernelOutputId.Add(item.KernelOutputId, new List <KernelOutputTranslaterData>());
}
if (_dicByKernelOutputId[item.KernelOutputId].All(a => a.GetId() != item.GetId()))
{
_dicByKernelOutputId[item.KernelOutputId].Add(item);
}
}
foreach (var item in _dicByKernelOutputId.Values)
{
item.Sort(new SortNumberComparer());
}
_isInited = true;
}
}
}
private void Init()
{
lock (_locker) {
if (!_isInited)
{
var repository = NTMinerRoot.CreateServerRepository <KernelOutputFilterData>(_isUseJson);
foreach (var item in repository.GetAll())
{
if (!_dicById.ContainsKey(item.GetId()))
{
_dicById.Add(item.GetId(), item);
}
if (!_dicByKernelOutputId.ContainsKey(item.KernelOutputId))
{
_dicByKernelOutputId.Add(item.KernelOutputId, new List <KernelOutputFilterData>());
}
if (_dicByKernelOutputId[item.KernelOutputId].All(a => a.GetId() != item.GetId()))
{
_dicByKernelOutputId[item.KernelOutputId].Add(item);
}
}
_isInited = true;
}
}
}
private MainWindowViewModel()
{
if (Design.IsInDesignMode)
{
return;
}
this.StartMine = new DelegateCommand(() => {
this.StateBarVm.IsMining = true;
NTMinerRoot.Current.StartMine();
});
this.StopMine = new DelegateCommand(() => {
if (!NTMinerRoot.Current.IsMining)
{
this.StateBarVm.IsMining = false;
}
NTMinerRoot.Current.StopMineAsync();
});
this.UseThisPcName = new DelegateCommand(() => {
string thisPcName = NTMinerRoot.GetThisPcName();
DialogWindow.ShowDialog(message: $"确定使用本机名{thisPcName}作为矿机名吗？", title: "确认", onYes: () => {
MinerProfile.MinerName = thisPcName;
}, icon: IconConst.IconConfirm);
});
if (DevMode.IsDevMode)
{
VirtualRoot.On <ServerJsonVersionChangedEvent>("在开发者调试区展示ServerJsonVersion", LogEnum.DevConsole,
action: message => {
this.ServerJsonVersion = NTMinerRoot.JsonFileVersion;
});
_serverJsonVersion = NTMinerRoot.JsonFileVersion;
}
}
private static CoinProfileData GetCoinProfileData(Guid coinId)
{
var repository = NTMinerRoot.CreateLocalRepository <CoinProfileData>();
var result = repository.GetByKey(coinId);
return(result);
}
private void Init()
{
lock (_locker) {
if (!_isInited)
{
var repository = NTMinerRoot.CreateCompositeRepository <SysDicItemData>(_isUseJson);
foreach (var item in repository.GetAll())
{
if (!_dicById.ContainsKey(item.GetId()))
{
_dicById.Add(item.GetId(), item);
}
if (!_dicByDicId.ContainsKey(item.DicId))
{
_dicByDicId.Add(item.DicId, new Dictionary <string, SysDicItemData>(StringComparer.OrdinalIgnoreCase));
}
if (!_dicByDicId[item.DicId].ContainsKey(item.Code))
{
_dicByDicId[item.DicId].Add(item.Code, item);
}
}
_isInited = true;
}
}
}
private void Init()
{
lock (_locker) {
if (!_isInited)
{
var repository = NTMinerRoot.CreateServerRepository <PoolKernelData>();
List <PoolKernelData> list = repository.GetAll().ToList();
foreach (IPool pool in _root.PoolSet)
{
foreach (ICoinKernel coinKernel in _root.CoinKernelSet.Where(a => a.CoinId == pool.CoinId))
{
PoolKernelData poolKernel = list.FirstOrDefault(a => a.PoolId == pool.GetId() && a.KernelId == coinKernel.KernelId);
if (poolKernel != null)
{
_dicById.Add(poolKernel.GetId(), poolKernel);
}
else
{
Guid poolKernelId = Guid.NewGuid();
_dicById.Add(poolKernelId, new PoolKernelData()
{
Id = poolKernelId,
Args = string.Empty,
Description = string.Empty,
KernelId = coinKernel.KernelId,
PoolId = pool.GetId()
});
}
}
}
_isInited = true;
}
}
}
private VirtualMemorySetViewModel()
{
#if DEBUG
NTStopwatch.Start();
#endif
foreach (var item in GetPagingFiles())
{
_initialVms.Add(item.DriveName, item);
}
foreach (var drive in AppContext.Instance.DriveSetVm.Drives)
{
_dic.Add(drive.Name, new VirtualMemoryViewModel(drive.Name, 0));
}
foreach (var item in _initialVms.Values)
{
if (_dic.TryGetValue(item.DriveName, out VirtualMemoryViewModel vm))
{
vm.MaxSizeMb = item.MaxSizeMb;
}
}
NTMinerRoot.SetOSVirtualMemoryMb(_dic.Values.Sum(a => a.MaxSizeMb));
#if DEBUG
var elapsedMilliseconds = NTStopwatch.Stop();
if (elapsedMilliseconds.ElapsedMilliseconds > NTStopwatch.ElapsedMilliseconds)
{
Write.DevTimeSpan($"耗时{elapsedMilliseconds} {this.GetType().Name}.ctor");
}
#endif
}
private void Init()
{
lock (_locker) {
if (!_isInited)
{
var repository = NTMinerRoot.CreateCompositeRepository <PoolData>();
List <PoolData> data = repository.GetAll().ToList();
if (VirtualRoot.IsMinerStudio)
{
foreach (var item in Server.PoolService.GetPools())
{
data.Add(item);
}
}
foreach (var item in data)
{
if (!_dicById.ContainsKey(item.GetId()))
{
_dicById.Add(item.GetId(), item);
}
}
_isInited = true;
}
}
}
private static CoinProfileData GetCoinProfileData(MineWorkData mineWorkData, Guid coinId)
{
bool isUseJson = mineWorkData != null;
IRepository <CoinProfileData> repository = NTMinerRoot.CreateLocalRepository <CoinProfileData>(isUseJson);
var result = repository.GetByKey(coinId);
return(result);
}
private void Init(INTMinerRoot root, MineWorkData mineWorkData)
{
MineWork = mineWorkData;
isUseJson = mineWorkData != null;
if (isUseJson)
{
_data = NTMinerRoot.LocalJson.MinerProfile;
}
else
{
IRepository <MinerProfileData> repository = NTMinerRoot.CreateLocalRepository <MinerProfileData>(false);
_data = repository.GetAll().FirstOrDefault();
}
if (_data == null)
{
Guid coinId = Guid.Empty;
ICoin coin = root.CoinSet.OrderBy(a => a.SortNumber).FirstOrDefault();
if (coin != null)
{
coinId = coin.GetId();
}
_data = MinerProfileData.CreateDefaultData(coinId);
}
if (_coinProfileSet == null)
{
_coinProfileSet = new CoinProfileSet(root, mineWorkData);
}
else
{
_coinProfileSet.Refresh(mineWorkData);
}
if (_coinKernelProfileSet == null)
{
_coinKernelProfileSet = new CoinKernelProfileSet(root, mineWorkData);
}
else
{
_coinKernelProfileSet.Refresh(mineWorkData);
}
if (_poolProfileSet == null)
{
_poolProfileSet = new PoolProfileSet(root, mineWorkData);
}
else
{
_poolProfileSet.Refresh(mineWorkData);
}
if (_walletSet == null)
{
_walletSet = new WalletSet(root);
}
else
{
_walletSet.Refresh();
}
}
private static CoinKernelProfileData GetCoinKernelProfileData(Guid coinKernelId)
{
IRepository <CoinKernelProfileData> repository = NTMinerRoot.CreateLocalRepository <CoinKernelProfileData>();
var result = repository.GetByKey(coinKernelId);
if (result == null)
{
result = CoinKernelProfileData.CreateDefaultData(coinKernelId);
}
return(result);
}
public void SetVirtualMemoryOfDrive()
{
List <VirtualMemoryViewModel> virtualMemories = _dic.Values.Where(a => a.MaxSizeMb != 0).ToList();
string[] value = virtualMemories.Select(a => a.ToString()).ToArray();
Windows.WinRegistry.SetValue(Registry.LocalMachine, MemoryManagementSubKey, "PagingFiles", value);
OnPropertyChanged(nameof(TotalVirtualMemoryMb));
OnPropertyChanged(nameof(IsStateChanged));
NTMinerRoot.SetOSVirtualMemoryMb(_dic.Values.Sum(a => a.MaxSizeMb));
}
private void AddWallet(WalletData entity)
{
if (VirtualRoot.IsMinerStudio)
{
Server.ControlCenterService.AddOrUpdateWalletAsync(entity, null);
}
else
{
var repository = NTMinerRoot.CreateLocalRepository <WalletData>();
repository.Add(entity);
}
}
private static CoinKernelProfileData GetCoinKernelProfileData(MineWorkData mineWorkData, Guid coinKernelId)
{
bool isUseJson = mineWorkData != null;
IRepository <CoinKernelProfileData> repository = NTMinerRoot.CreateLocalRepository <CoinKernelProfileData>(isUseJson);
var result = repository.GetByKey(coinKernelId);
if (result == null)
{
result = CoinKernelProfileData.CreateDefaultData(coinKernelId);
}
return(result);
}
public PoolKernelSet(INTMinerRoot root, bool isUseJson)
{
_root = root;
_isUseJson = isUseJson;
VirtualRoot.Window <AddPoolKernelCommand>("处理添加矿池级内核命令", LogEnum.DevConsole,
action: message => {
if (!_dicById.ContainsKey(message.Input.GetId()))
{
var entity = new PoolKernelData().Update(message.Input);
_dicById.Add(message.Input.GetId(), entity);
var repository = NTMinerRoot.CreateServerRepository <PoolKernelData>(isUseJson);
repository.Add(entity);
VirtualRoot.Happened(new PoolKernelAddedEvent(message.Input));
}
}).AddToCollection(root.ContextHandlers);
VirtualRoot.Window <RemovePoolKernelCommand>("处理移除矿池级内核命令", LogEnum.DevConsole,
action: message => {
if (_dicById.ContainsKey(message.EntityId))
{
var entity = _dicById[message.EntityId];
_dicById.Remove(message.EntityId);
var repository = NTMinerRoot.CreateServerRepository <PoolKernelData>(isUseJson);
repository.Remove(message.EntityId);
VirtualRoot.Happened(new PoolKernelRemovedEvent(entity));
}
}).AddToCollection(root.ContextHandlers);
VirtualRoot.Window <UpdatePoolKernelCommand>("更新矿池内核", LogEnum.DevConsole,
action: (message) => {
InitOnece();
if (message == null || message.Input == null || message.Input.GetId() == Guid.Empty)
{
throw new ArgumentNullException();
}
if (!_root.PoolSet.Contains(message.Input.PoolId))
{
throw new ValidationException("there is no pool with id" + message.Input.PoolId);
}
if (!_dicById.ContainsKey(message.Input.GetId()))
{
return;
}
PoolKernelData entity = _dicById[message.Input.GetId()];
if (ReferenceEquals(entity, message.Input))
{
return;
}
entity.Update(message.Input);
var repository = NTMinerRoot.CreateServerRepository <PoolKernelData>(isUseJson);
repository.Update(entity);
VirtualRoot.Happened(new PoolKernelUpdatedEvent(entity));
}).AddToCollection(root.ContextHandlers);
}
private void RemoveWallet(Guid id)
{
if (VirtualRoot.IsMinerStudio)
{
Server.ControlCenterService.RemoveWalletAsync(id, null);
}
else
{
var repository = NTMinerRoot.CreateLocalRepository <WalletData>(isUseJson: false);
repository.Remove(id);
}
}
private void RemoveWallet(Guid id)
{
if (VirtualRoot.IsMinerStudio)
{
RpcRoot.Server.WalletService.RemoveWalletAsync(id, null);
}
else
{
var repository = NTMinerRoot.CreateLocalRepository <WalletData>();
repository.Remove(id);
}
}
private void UpdateWallet(WalletData entity)
{
if (VirtualRoot.IsMinerStudio)
{
RpcRoot.Server.WalletService.AddOrUpdateWalletAsync(entity, null);
}
else
{
var repository = NTMinerRoot.CreateLocalRepository <WalletData>();
repository.Update(entity);
}
}
private void RemoveWallet(Guid id)
{
if (UseRemoteWalletList)
{
Server.ControlCenterService.RemoveWallet(id, null);
}
else
{
var repository = NTMinerRoot.CreateLocalRepository <WalletData>();
repository.Remove(id);
}
}
private void UpdateWallet(WalletData entity)
{
if (UseRemoteWalletList)
{
Server.ControlCenterService.AddOrUpdateWallet(entity, null);
}
else
{
var repository = NTMinerRoot.CreateLocalRepository <WalletData>();
repository.Update(entity);
}
}
public PoolKernelSet(IServerContext context)
{
_context = context;
_context.AddCmdPath <AddPoolKernelCommand>("处理添加矿池级内核命令", LogEnum.DevConsole,
action: message => {
if (!_dicById.ContainsKey(message.Input.GetId()))
{
var entity = new PoolKernelData().Update(message.Input);
_dicById.Add(message.Input.GetId(), entity);
var repository = NTMinerRoot.CreateServerRepository <PoolKernelData>();
repository.Add(entity);
VirtualRoot.RaiseEvent(new PoolKernelAddedEvent(message.MessageId, message.Input));
}
}, location: this.GetType());
_context.AddCmdPath <RemovePoolKernelCommand>("处理移除矿池级内核命令", LogEnum.DevConsole,
action: message => {
if (_dicById.ContainsKey(message.EntityId))
{
var entity = _dicById[message.EntityId];
_dicById.Remove(message.EntityId);
var repository = NTMinerRoot.CreateServerRepository <PoolKernelData>();
repository.Remove(message.EntityId);
VirtualRoot.RaiseEvent(new PoolKernelRemovedEvent(message.MessageId, entity));
}
}, location: this.GetType());
_context.AddCmdPath <UpdatePoolKernelCommand>("更新矿池内核", LogEnum.DevConsole,
action: (message) => {
InitOnece();
if (message == null || message.Input == null || message.Input.GetId() == Guid.Empty)
{
throw new ArgumentNullException();
}
if (!_context.PoolSet.Contains(message.Input.PoolId))
{
throw new ValidationException("there is no pool with id" + message.Input.PoolId);
}
if (!_dicById.ContainsKey(message.Input.GetId()))
{
return;
}
PoolKernelData entity = _dicById[message.Input.GetId()];
if (ReferenceEquals(entity, message.Input))
{
return;
}
entity.Update(message.Input);
var repository = NTMinerRoot.CreateServerRepository <PoolKernelData>();
repository.Update(entity);
VirtualRoot.RaiseEvent(new PoolKernelUpdatedEvent(message.MessageId, entity));
}, location: this.GetType());
}
private void Init(INTMinerRoot root)
{
IRepository <MinerProfileData> minerProfileRepository = NTMinerRoot.CreateLocalRepository <MinerProfileData>();
_data = minerProfileRepository.GetAll().FirstOrDefault();
IRepository <MineWorkData> mineWorkRepository = NTMinerRoot.CreateLocalRepository <MineWorkData>();
MineWork = mineWorkRepository.GetAll().FirstOrDefault();
if (_data == null)
{
Guid coinId = Guid.Empty;
ICoin coin = root.CoinSet.OrderBy(a => a.Code).FirstOrDefault();
if (coin != null)
{
coinId = coin.GetId();
}
_data = MinerProfileData.CreateDefaultData(coinId);
}
if (_coinProfileSet == null)
{
_coinProfileSet = new CoinProfileSet(root);
}
else
{
_coinProfileSet.Refresh();
}
if (_coinKernelProfileSet == null)
{
_coinKernelProfileSet = new CoinKernelProfileSet(root);
}
else
{
_coinKernelProfileSet.Refresh();
}
if (_poolProfileSet == null)
{
_poolProfileSet = new PoolProfileSet(root);
}
else
{
_poolProfileSet.Refresh();
}
if (_walletSet == null)
{
_walletSet = new WalletSet(root);
}
else
{
_walletSet.Refresh();
}
}
private static PoolProfileData GetPoolProfileData(INTMinerRoot root, Guid poolId)
{
IRepository <PoolProfileData> repository = NTMinerRoot.CreateLocalRepository <PoolProfileData>();
var result = repository.GetByKey(poolId);
if (result == null)
{
if (root.PoolSet.TryGetPool(poolId, out IPool pool))
{
// 如果本地未设置用户名密码则使用默认的测试用户名密码
result = PoolProfileData.CreateDefaultData(pool);
}
}
return(result);
}
protected override void OnContentRendered(EventArgs e)
{
base.OnContentRendered(e);
System.Windows.Forms.Keys hotKey = System.Windows.Forms.Keys.X;
Enum.TryParse(NTMinerRoot.GetHotKey(), out hotKey);
string message;
if (!RegHotKey(hotKey, out message))
{
NotiCenterWindowViewModel.Current.Manager
.CreateMessage()
.Error(message)
.Dismiss().WithButton("忽略", null)
.Queue();
}
}
public CoinGroupSet(INTMinerRoot root)
{
_root = root;
Global.Access <AddCoinGroupCommand>(
Guid.Parse("2dd8f7e9-c79d-4621-954f-9fc45b0207dd"),
"添加币组",
LogEnum.Log,
action: (message) => {
InitOnece();
if (message == null || message.Input == null || message.Input.GetId() == Guid.Empty)
{
throw new ArgumentNullException();
}
if (_dicById.ContainsKey(message.Input.GetId()))
{
return;
}
CoinGroupData entity = new CoinGroupData().Update(message.Input);
_dicById.Add(entity.Id, entity);
var repository = NTMinerRoot.CreateServerRepository <CoinGroupData>();
repository.Add(entity);
Global.Happened(new CoinGroupAddedEvent(entity));
});
Global.Access <RemoveCoinGroupCommand>(
Guid.Parse("e52874f4-37d8-4d49-a637-5b95aa89367e"),
"移除币组",
LogEnum.Log,
action: (message) => {
InitOnece();
if (message == null || message.EntityId == Guid.Empty)
{
throw new ArgumentNullException();
}
if (!_dicById.ContainsKey(message.EntityId))
{
return;
}
CoinGroupData entity = _dicById[message.EntityId];
_dicById.Remove(entity.GetId());
var repository = NTMinerRoot.CreateServerRepository <CoinGroupData>();
repository.Remove(message.EntityId);
Global.Happened(new CoinGroupRemovedEvent(entity));
});
Global.Logger.InfoDebugLine(this.GetType().FullName + "接入总线");
}
private void Init()
{
lock (_locker) {
if (!_isInited)
{
var repository = NTMinerRoot.CreateCompositeRepository <KernelOutputKeywordData>(_isUseJson);
foreach (var item in repository.GetAll())
{
if (!_dicById.ContainsKey(item.GetId()))
{
_dicById.Add(item.GetId(), item);
}
}
_isInited = true;
}
}
}
private void Init()
{
lock (_locker) {
if (!_isInited)
{
var repository = NTMinerRoot.CreateServerRepository <CoinKernelData>();
foreach (var item in repository.GetAll())
{
if (!_dicById.ContainsKey(item.GetId()))
{
_dicById.Add(item.GetId(), item);
}
}
_isInited = true;
}
}
}
private MinerProfileData GetMinerProfileData()
{
if (CommandLineArgs.IsWorker)
{
return(Server.ProfileService.GetMinerProfile(CommandLineArgs.WorkId));
}
else
{
IRepository <MinerProfileData> repository = NTMinerRoot.CreateLocalRepository <MinerProfileData>();
var result = repository.GetAll().FirstOrDefault();
if (result == null)
{
result = MinerProfileData.CreateDefaultData();
}
return(result);
}
}
private CoinProfileData GetCoinProfileData(Guid coinId)
{
if (CommandLineArgs.IsWorker)
{
return(Server.ProfileService.GetCoinProfile(CommandLineArgs.WorkId, coinId));
}
else
{
IRepository <CoinProfileData> repository = NTMinerRoot.CreateLocalRepository <CoinProfileData>();
var result = repository.GetByKey(coinId);
if (result == null)
{
result = CoinProfileData.CreateDefaultData(coinId);
}
return(result);
}
}
