public SelectGameResponse(JsonData data)
{
try {
machine = new MachineInfo(data["game_info"]);
}
catch(Exception e) {
Debug.Log(e);
}
}
public void ResetWithResponse(SelectGameResponse resp)
{
info = resp.machine;
ResetReelOwner();
CreateReelIcons();
UpdateLineColors();
UpdateLines ();
UpdatePayoutInfo();
}
void ReadMachineInfo(JsonData jd)
{
machineInfo = new MachineInfo();
machineInfo.ParseSlots(jd["slots"]);
machineInfo.ParsePayouts(jd["payouts"]);
machineInfo.ParseLines (jd["lines"]);
machineInfo.ParseGemOdds(jd["gem_odds"]);
ParseReels(jd["reels"]);
}
public bool DoesMatch(int[] spin, MachineInfo info)
{
for(var i = 0; i < 5; i++) {
var spinIdx = spin[i];
var lineIdx = info.IdForName (line[i]);
var isWild = (spinIdx == info.IdForName("Wild"));
if(lineIdx != info.IdForName("Any") && !isWild && lineIdx != spinIdx) {
return false;
}
}
return true;
}
public static MachineInfo localMachine()
{
using (var dbcontext = new SqliteDbContext())
{
var find = dbcontext.MachineInfos.FirstOrDefault();
if (find == null)
{
find = new MachineInfo();
dbcontext.InsertOrReplace(find);
find = dbcontext.MachineInfos.FirstOrDefault();
}
return(find);
}
}
static MachineInfo GatherMachineInfo()
{
var info = new MachineInfo();
info.ProcessorCount = Environment.ProcessorCount;
info.Is64BitOS = Environment.Is64BitOperatingSystem;
info.Is64Bit = Environment.Is64BitProcess;
info.OS = Environment.OSVersion;
info.WorkingSet = Environment.WorkingSet;
info.WorkingSetGB = Environment.WorkingSet / 1024.0 / 1024 / 1024;
info.HighResStopwatch = Stopwatch.IsHighResolution;
info.StopwatchFrequency = Stopwatch.Frequency;
return(info);
}
public static void GetMachineResponse(MachineInfo instances, ByteArray byteArray)
{
byteArray.Reset();
byteArray.WriteHeader();
byteArray.writeInt(EnumDeamonMethods.CLIENT_GETMACHINERESPONSE_HASH);
byteArray.EncryptKey = EnumDeamonMethods.CLIENT_GETMACHINERESPONSE_HASH;
byteArray.CRC = 0;
byteArray.writeDynamicsInt(ByteArray.globalSeq);
instances.WriteToByteArray(byteArray);
++ByteArray.globalSeq;
byteArray.writeIntNCRC(byteArray.CRC);
byteArray.EncryptKey = 0;
}
private static void Test1()
{
var b = (Byte)0x0F;
XTrace.WriteLine("{0} {0:X} {0:X2}", b);
// 15 F 0F
//var keys = ECDsaHelper.GenerateKey();
//XTrace.WriteLine("prvKey:{0}", keys[0]);
//XTrace.WriteLine("pubKey:{0}", keys[1]);
//"你好".SpeakAsync();
XTrace.WriteLine("FullPath:{0}", ".".GetFullPath());
XTrace.WriteLine("BasePath:{0}", ".".GetBasePath());
XTrace.WriteLine("TempPath:{0}", Path.GetTempPath());
var mi = MachineInfo.Current ?? MachineInfo.RegisterAsync().Result;
foreach (var pi in mi.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
XTrace.WriteLine("{0}:\t{1}", pi.Name, mi.GetValue(pi));
}
Console.WriteLine();
#if __CORE__
foreach (var pi in typeof(RuntimeInformation).GetProperties())
{
XTrace.WriteLine("{0}:\t{1}", pi.Name, pi.GetValue(null));
}
#endif
//Console.WriteLine();
//foreach (var pi in typeof(Environment).GetProperties())
//{
// XTrace.WriteLine("{0}:\t{1}", pi.Name, pi.GetValue(null));
//}
mi = MachineInfo.Current;
for (var i = 0; i < 100; i++)
{
XTrace.WriteLine("CPU={0:p2} Temp={1} Memory={2:n0} Disk={3}", mi.CpuRate, mi.Temperature, mi.AvailableMemory.ToGMK(), MachineInfo.GetFreeSpace().ToGMK());
Thread.Sleep(1000);
mi.Refresh();
}
Console.ReadKey();
}
public Machine CreateMachine(MachineInfo machineInfo, Bounds3Int bounds)
{
if (bounds.size != machineInfo.size)
{
Debug.LogWarning("Machine bounds does not match machine info");
bounds = Bounds3Int.Create(bounds.min, machineInfo.size);
}
if (CanCreateMachine(machineInfo, bounds))
{
CurrencySystem.instance.BuildMachine(machineInfo);
return(DoCreateMachine(machineInfo, bounds));
}
return(null);
}
public void ToStringTest()
{
MachineInfo machineInfo = MachineInfo.Instance;
Assert.IsTrue(machineInfo.MachineName.Length > 0);
Assert.IsTrue(machineInfo.PhysicalProcessorsNumber > 0);
Assert.IsTrue(machineInfo.PhysicalCoresNumber > 0);
Assert.IsTrue(machineInfo.LogicalCoresNumber > 0);
Assert.IsTrue(machineInfo.CpusSpeedInMHz.Count > 0);
Assert.IsTrue(machineInfo.CpusSpeedInMHz[0] > 1000);
Assert.IsTrue(machineInfo.TotalPhysicalMemoryInGB > 2);
Assert.IsTrue(machineInfo.PhysicalHDDsNumber > 0);
Assert.IsTrue(machineInfo.HddsTypes.Count > 0);
}
public static SystemStructure CreateDefault()
{
SystemStructure sys = new SystemStructure();
MachineInfo m1 = new MachineInfo(0, "Computer 1");
m1.MachineFunc = MachineInfo.Function.Defense;
m1.PosX = 0;
m1.PosZ = 0;
MachineInfo m2 = new MachineInfo(1, "Computer 2");
m2.PosX = 5;
m2.PosZ = 5;
MachineInfo m3 = new MachineInfo(2, "Computer 3");
m3.MachineFunc = MachineInfo.Function.Power;
m3.PosX = -5;
m3.PosZ = 0;
MachineInfo m4 = new MachineInfo(3, "Computer 4");;
m4.PosX = 7;
m4.PosZ = 0;
MachineInfo m5 = new MachineInfo(4, "Computer 5");
m5.PosX = 5;
m5.PosZ = -5;
m1.AddConnect(m2);
m1.AddConnect(m4);
m1.AddConnect(m5);
m3.AddConnect(m1);
m2.AddConnect(m4);
m2.AddConnect(m5);
sys.Machines.Add(m1);
sys.Machines.Add(m2);
sys.Machines.Add(m3);
sys.Machines.Add(m4);
sys.Machines.Add(m5);
return(sys);
}
public EvoCalibrationWin(MachineInfo _MachineInfo)
{
InitializeComponent();
this._MachineInfo = _MachineInfo;
this.grd_test.Visibility = Visibility.Hidden;
grd_test_temp.Visibility = System.Windows.Visibility.Hidden;
this.grd_cal.Visibility = System.Windows.Visibility.Hidden;
grd_test_brew.Visibility = System.Windows.Visibility.Hidden;
this.grd_Process.Visibility = System.Windows.Visibility.Hidden;
Tmr.Interval = TimeSpan.FromSeconds(5);
Tmr.Tick += Tmr_Tick;
Tmrpb.Interval = TimeSpan.FromSeconds(0.1);
Tmrpb.Tick += Tmrpb_Tick;
comunication.EVOEvent += comunication_EVOEvent;
}
internal override void Load(MachineInfo machineInfo)
{
if (machineInfo.MachineData.HasKey("axis-" + Name + "-method"))
{
Method = (ChainMethod)Enum.Parse(typeof(ChainMethod), machineInfo.MachineData.ReadString("axis-" + Name + "-method"));
}
if (machineInfo.MachineData.HasKey("axis-" + Name + "-subaxis1"))
{
SubAxis1 = machineInfo.MachineData.ReadString("axis-" + Name + "-subaxis1");
}
if (machineInfo.MachineData.HasKey("axis-" + Name + "-subaxis2"))
{
SubAxis2 = machineInfo.MachineData.ReadString("axis-" + Name + "-subaxis2");
}
}
public static ByteArray GetMachineResponse(MachineInfo instances)
{
ByteArray byteArray = new ByteArray();
byteArray.writeInt(EnumDeamonMethods.CLIENT_GETMACHINERESPONSE_HASH);
byteArray.EncryptKey = EnumDeamonMethods.CLIENT_GETMACHINERESPONSE_HASH;
byteArray.CRC = 0;
byteArray.writeDynamicsInt(ByteArray.globalSeq);
instances.WriteToByteArray(byteArray);
++ByteArray.globalSeq;
byteArray.writeInt(byteArray.CRC);
byteArray.EncryptKey = 0;
return(byteArray);
}
Machine DoCreateMachine(MachineInfo machineInfo, Bounds3Int bounds)
{
GameObject gameObject = new GameObject(machineInfo.machineName);
Machine machine = gameObject.AddComponent <Machine>();
machine.bounds = bounds;
machine.machineInfo = machineInfo;
Add(machine);
machine.Initialize();
Events.MachineCreated?.Invoke(machine);
return(machine);
}
public static void RecordMachineInfo(MachineInfo machineinfo)
{
var localmachine = localMachine();
localmachine.username = machineinfo.username;
localmachine.machineId = machineinfo.machineId;
localmachine.machineName = machineinfo.machineName;
localmachine.machinepwd = machineinfo.machinepwd;
localmachine.token = machineinfo.token;
using (var dbcontext = new SqliteDbContext())
{
dbcontext.Update(localmachine);
}
}
private void AddMachineInfo(MachineInfo minfo)
{
if (minfo.OSType != "DOESNOTEXIST")
{
serversfound.Add(minfo);
}
lock (_locker)
{
usablenumber--;
}
if (usablenumber == 0)
{
iscomplete = true;
}
}
public OrdersDetails ClearOrder([FromBody] MachineInfo requestParams)
{
var shoppingcart = ShoppingCartFactory.Factory(requestParams.StoreId, requestParams.MachineSn, requestParams.CID, requestParams.DeviceSn);
shoppingcart.Clear();
var result = new OrdersDetails()
{
BuyList = shoppingcart.GetBuyList(),
Gifts = new List <GiftResult>(),
Statistics = shoppingcart.GetSaleStatistics()
};
ShoppingCartFactory.ResetCache(shoppingcart, requestParams.StoreId, requestParams.MachineSn, requestParams.CID, requestParams.DeviceSn);
return(result);
}
public EmitContext(MachineInfo machineInfo, Report report, CompiledFunction fdecl = null)
{
if (machineInfo == null)
{
throw new ArgumentNullException(nameof(machineInfo));
}
if (report == null)
{
throw new ArgumentNullException(nameof(report));
}
MachineInfo = machineInfo;
Report = report;
FunctionDecl = fdecl;
}
internal override void Load(MachineInfo machineInfo)
{
if (machineInfo.MachineData.HasKey("axis-" + Name + "-axis"))
{
Axis = (Axis)machineInfo.MachineData.ReadInt("axis-" + Name + "-axis");
}
if (machineInfo.MachineData.HasKey("axis-" + Name + "-center"))
{
Center = machineInfo.MachineData.ReadFloat("axis-" + Name + "-center");
}
if (machineInfo.MachineData.HasKey("axis-" + Name + "-range"))
{
Range = machineInfo.MachineData.ReadFloat("axis-" + Name + "-range");
}
}
static void Test1()
{
var ip = "180.165.235.0".IPToAddress();
Console.WriteLine(ip);
var mi = new MachineInfo();
foreach (var pi in mi.GetType().GetProperties())
{
Console.WriteLine("{0}:\t{1}", pi.Name, mi.GetValue(pi));
}
Console.ReadKey();
}
private void button17_Click(object sender, EventArgs e)
{
if (f17 == null)
{
return;
}
string tmp;
File.Copy(f17, tmp = MachineInfo.GetTempFilePathWithExtension(".tmp"));
Process pad = new Process();
pad.StartInfo.FileName = "notepad.exe";
pad.StartInfo.Arguments = tmp;
pad.Start();
}
public MachineInfoDetailViewModel(MachineInfoDetailView view)
{
_view = view;
_machineInfo = new MachineInfo();
OSInfo1_List = new List <string>();
OSInfo2_List = new List <string>();
_osDetailUpdated += _osDetailUpdatedHandler;
_osDetailCompleted += _osDetailCompletedHandler;
_context = new DataContext();
OSInfo0_List = (from o in _context.tbl_OSInfo
select o.Platform).Distinct().ToList();
}
/// <summary>
/// 试剂1探测余量
/// </summary>
private void ResidueR1()
{
if (this.gridView1.SelectedRowsCount > 0)
{
if (SendNetworkCommandEvent != null)
{
Command cmd = MachineInfo.GetCommandByName("RGTPanel1VolScan");
string pos = "";
for (int i = 0; i < this.gridView1.SelectedRowsCount; i++)
{
int selectedHandle = this.gridView1.GetSelectedRows()[i];
string position = this.gridView1.GetRowCellValue(selectedHandle, "试剂1位置").ToString().Trim();
if (position == "" || position == null)
{
continue;
}
else
{
pos += position + "|";
}
}
if (pos == "")
{
return;
}
cmd.Para = "1:" + pos.TrimEnd('|');
cmd.State = 1;
var ResidueR1Thread = new Thread(() =>
{
//发送命令
SendNetworkCommandEvent(cmd);
});
ResidueR1Thread.IsBackground = true;
ResidueR1Thread.Start();
}
}
else
{
MessageBoxDraw.ShowMsg("请选择待检测余量的项目！", MsgType.Warning);
}
}
private void OnNewComponentManagerEvent(ComponentManagerEventArgs e)
{
Logger.LogInfo(this, "OnNewComponentManagerEvent()");
string machineIp = MachineInfo.GetIP(false);
Logger.LogDebug(this, "machineIp:{0}", machineIp);
CommMessage msg = new CommMessage(machineIp,
e.Component.GetCommandCode(),
e.ComponentArgs.IsBinary,
e.Component.GetName(),
e.ComponentArgs.Timestamp,
e.ComponentArgs.Size,
e.ComponentArgs.Data);
CommManager.AppendMessage(msg);
}
/// <summary>
/// Determines whether the specified System.Object is equal
/// to the current System.Object.
/// </summary>
/// <param name="obj">Object</param>
/// <returns>Boolean</returns>
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
MachineInfo mid = obj as MachineInfo;
if (mid == null)
{
return(false);
}
return(MachineId == mid.MachineId);
}
private static bool OnGetMachineResponse(ByteArray byteArray, IDeamonClientService clientService)
{
MachineInfo instances = new MachineInfo();
instances.ReadFromByteArray(byteArray);
int crc = byteArray.readIntNCRC();
if (crc == byteArray.CRC)
{
clientService.OnGetMachineResponse(ref instances);
}
byteArray.Recycle();
return(true);
}
private MachineInfo GetMachineInformation()
{
MachineInfo result = new MachineInfo();
ManagementObjectSearcher searcher = new ManagementObjectSearcher("select * from Win32_Processor");
foreach (var obj in searcher.Get())
{
CPUInfo info = new CPUInfo();
info.Name = (string)obj.GetPropertyValue("Name");
info.ProcessorID = (string)obj.GetPropertyValue("ProcessorID");
result.CPU.Add(info);
}
return(result);
}
public void Execute(IJobExecutionContext context)
{
var username = context.MergedJobDataMap["username"] as string;
IExchange exchange = context.MergedJobDataMap["IExchange"] as IExchange;
IAdvancedPublishChannel boxPublishChannel = context.MergedJobDataMap["IAdvancedPublishChannel"] as IAdvancedPublishChannel;
MachineInfo machineInfo = context.MergedJobDataMap["MachineInfo"] as MachineInfo;
machineInfo.Update();
Console.WriteLine("Execute: " + DateTime.Now + ", CpuUsage: " + machineInfo.CpuUsage);
var message = new Message <MachineInfo>(machineInfo);
message.Properties.UserId = username;
boxPublishChannel.Publish <MachineInfo>(exchange, "info", message);
}
// 软件注册，记录注册码到注册表中
private void button1_Click(object sender, EventArgs e)
{
string serial = textBox_SerialNum.Text.Trim();
serial = MachineInfo.format(serial);
if (serial.Equals(MachineInfo.RegSerial()))
{
mainForm.F.RegistrySave(@"Scimence\easyIcon\Set", "Serial", serial);
this.Close();
MessageBox.Show("恭喜，您已成功注册！");
}
else
{
MessageBox.Show("抱歉，注册码无效！");
}
}
private void sendItemsToConveyorBelt(MachineInfo machineInfo)
{
bool hasItemsToSend = false;
foreach (ItemUI item in machineInfo.itemsThatProduces)
{
if (storedItems.ContainsKey(item.type) && storedItems[item.type] > 0)
{
hasItemsToSend = true;
break;
}
}
if (!hasItemsToSend)
{
return;
}
// know how many output connections has to divide the output between
int outputConnections = 0;
foreach (KeyValuePair <Vector3, ConnectionType> connection in connections)
{
if (connection.Value == ConnectionType.Output && ((Belt)GameGrid.Instance.getMachineAt(connection.Key)).hasFreeSlots)
{
outputConnections++;
}
}
if (outputConnections < 1)
{
return;
}
// TEMPORAL
storedItems[machineInfo.itemsThatProduces.First().type]--;
foreach (KeyValuePair <Vector3, ConnectionType> connection in connections)
{
Belt belt = (Belt)GameGrid.Instance.getMachineAt(connection.Key);
if (connection.Value == ConnectionType.Output && belt.hasFreeSlots)
{
belt.addItem(machineInfo.itemsThatProduces.First().type);
break;
}
}
}
public UserProfile GetUserVMDetail(string emailId)
{
UserProfile _return = null;
try
{
string spreadsheetId = Constant.Constant.UserSheetId;
string sheetName = Constant.Constant.UserSheetName;
string UserDefaultVmCol = Constant.Constant.UserDefaultVMColumn;
char UserDefaultVmColRowIndex = Constant.Constant.UserDefaultVMColumn[1];
char UserDefaultVmColIndex = Constant.Constant.UserDefaultVMColumn[0];
char UserResourceGroupColIndex = Constant.Constant.UserResourceGroupColumn[0];
int searchedRowIndex = GetUserEmailRowIndex(spreadsheetId, sheetName, emailId);
if (searchedRowIndex > 0)
{
List <MachineInfo> lstMachineInfo = new List <MachineInfo>();
for (char colIndex = UserDefaultVmColIndex; colIndex <= 'Z'; colIndex++)
{
MachineInfo machine = new MachineInfo();
string cellName = string.Concat(colIndex, searchedRowIndex);
string vmName = Convert.ToString(GetCellValue(spreadsheetId, sheetName, cellName));
if (vmName.Contains(Constant.Constant.SplitChar))
{
string[] machineInfo = Convert.ToString(vmName).Split(Constant.Constant.SplitChar.ToChar());
machine.MachineName = machineInfo[0].Trim();
machine.Resource_Group = machineInfo[1].Trim();
lstMachineInfo.Add(machine);
if (vmName.IsNull())
{
break;
}
}
}
_return = new UserProfile()
{
email = emailId,
machineInfo = lstMachineInfo
};
}
}
catch (Exception ex)
{
}
return(_return);
}
private static void Test1()
{
foreach (var item in Enum.GetValues(typeof(TypeCode)))
{
var t = (item + "").GetTypeEx();
Console.WriteLine("{0}\t{1}\t{2}", item, t, t?.IsPrimitive);
}
"你好".SpeakAsync();
XTrace.WriteLine("FullPath:{0}", ".".GetFullPath());
XTrace.WriteLine("BasePath:{0}", ".".GetBasePath());
XTrace.WriteLine("TempPath:{0}", Path.GetTempPath());
var mi = MachineInfo.Current ?? MachineInfo.RegisterAsync().Result;
foreach (var pi in mi.GetType().GetProperties())
{
XTrace.WriteLine("{0}:\t{1}", pi.Name, mi.GetValue(pi));
}
Console.WriteLine();
#if __CORE__
foreach (var pi in typeof(RuntimeInformation).GetProperties())
{
XTrace.WriteLine("{0}:\t{1}", pi.Name, pi.GetValue(null));
}
#endif
//Console.WriteLine();
//foreach (var pi in typeof(Environment).GetProperties())
//{
// XTrace.WriteLine("{0}:\t{1}", pi.Name, pi.GetValue(null));
//}
mi = MachineInfo.Current;
for (var i = 0; i < 100; i++)
{
XTrace.WriteLine("CPU={0:p2} Temp={1} Memory={2:n0} Disk={3}", mi.CpuRate, mi.Temperature, mi.AvailableMemory.ToGMK(), MachineInfo.GetFreeSpace().ToGMK());
Thread.Sleep(1000);
mi.Refresh();
}
Console.ReadKey();
}
/// <summary>加载存档信息</summary>
private void LoadConfiguration(MachineInfo mi)
{
#if DEBUG
ConsoleController.ShowMessage("载入存档");
#endif
//if (Machine.Active().gameObject.GetComponent<CameraCompositeTrackerScript>())
//{
// Machine.Active().gameObject.GetComponent<CameraCompositeTrackerScript>().previousTargetDic.Clear();
//}
MI = mi;
try { OnLoad(mi); } catch { }
StartCoroutine(RefreshSliders());
}
// Use this for initialization
void Start()
{
SetBuildObjectsActive();
GameUI activeGame = IS_CASINO_BUILD ? casinoGameDemo : socialGameDemo;
loginScreen.SetActive(!activeGame.USE_BAKED_LOGIC);
resSwitcher.ConfigureForResolution(IS_CASINO_BUILD);
if(activeGame.USE_BAKED_LOGIC) {
Debug.Log ("Parsing demo stuff on " + activeGame.name);
Application.targetFrameRate = 60;
parser = new MachineParser(jsonText.text);
machineInfo = parser.machineInfo;
machineInfo.SortPayouts();
DemoSpinner.sm_info = machineInfo;
ContentManager.Instance.Player = new Player();
activeGame.ResetWithResponse(new SelectGameResponse(machineInfo));
activeGame.UpdateLabels();
}
}
//
public DiagnosticViewModel(MachineInfo machineData)
{
_accessLevel |= 1 << (int)SmartCardGroups.Manufacturer;
_accessLevel |= 1 << (int)SmartCardGroups.Distributor;
var _arr = new System.Collections.BitArray(8);
_arr[(int)SmartCardGroups.Distributor] = true;
_machineData = machineData;
Hardware = new ObservableCollection<HardwareInfo>();
Software = new ObservableCollection<SoftwareInfo>();
GeneralList = new ObservableCollection<string>();
var ini = Properties.Resources.machine_ini;
var buffer = new StringBuilder(64);
NativeWinApi.GetPrivateProfileString("Exe", "Game Exe", "", buffer, 64, ini);
var hash = "";
var status = CheckHashIsAuthed(buffer, ref hash);
Software.Add(new SoftwareInfo("1524", hash, status));
for (var i = 0; i < BoLib.getNumberOfGames(); i++)
{
var exe = new StringBuilder(64);
var dir = new StringBuilder(64);
NativeWinApi.GetPrivateProfileString("Game" + (i + 1), "Exe", "", exe, 64, ini);
NativeWinApi.GetPrivateProfileString("Game" + (i + 1), "GameDirectory", "", dir, 64, ini);
var fullPath = new StringBuilder(dir + @"\" + exe);
status = CheckHashIsAuthed(fullPath, ref hash);
Software.Add(new SoftwareInfo(dir.ToString().TrimStart("\\".ToCharArray()), hash, status));
}
char[] licenseBuffer = new char[128];
NativeWinApi.GetPrivateProfileString("Keys", "License", "", licenseBuffer, 128, Properties.Resources.machine_ini);
//NativeWinApi.GetPrivateProfileString("Key", "License", "", licenseBuffer, 128, Properties.Resources.machine_ini);
string license = new string(licenseBuffer, 0, 128).Trim("\0".ToCharArray());
for (int i = 0; i < license.Length; i++)
{
if ((i % 15 == 0) && i > 0)
license = license.Insert(i, "-");
}
//var serial = BoLib.getSerialNumber();
Hardware.Add(new HardwareInfo()
{
SerialKey = BoLib.getSerialNumber(),//serial,
MachineName = System.Environment.MachineName, //"TERMINAL_01",
License = license,
CpuType = "S430",
CabinetType =/* (BoLib.GetUniquePcbID(0)) ? */"INNOCORE TS22 L29" /*: "AXIS - L29"*/,
CpuID = BoLib.GetUniquePcbID(0)
});
foreach (var ni in NetworkInterface.GetAllNetworkInterfaces())
{
if (ni.NetworkInterfaceType != NetworkInterfaceType.Wireless80211 &&
ni.NetworkInterfaceType != NetworkInterfaceType.Ethernet) continue;
foreach (var ip in ni.GetIPProperties().UnicastAddresses)
{
if (ip.Address.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork) continue;
Hardware[0].IPAddress = ip.Address.ToString();
Hardware[0].Subnet = ip.IPv4Mask.ToString();
Hardware[0].DefGateway = ni.GetIPProperties().GatewayAddresses[0].Address.ToString();
}
}
var code = MachineDescription.CountryCode; //BoLib.getCountryCode();
GeneralList.Add("Country Code: (" + code + ") " + BoLib.getCountryCodeStrLiteral("", code));
GeneralList.Add("Printer Port: COM2");
GeneralList.Add(BoLib.getEDCTypeStr());
GeneralList.Add(_machineData.GetScreenResolution());
GeneralList.Add(_machineData.GetOsVersion());
GeneralList.Add(_machineData.GetMemoryInfo());
GeneralList.Add("Game Provider: Project Coin");
GeneralList.Add(_machineData.GetUpdateKey());
GeneralList.Add("Last Security Check: " + _machineData.GetLastMd5Check());
RaisePropertyChangedEvent("PropertyChanged");
RaisePropertyChangedEvent("Hardware");
RaisePropertyChangedEvent("Software");
RaisePropertyChangedEvent("GeneralList");
}
private MachineInfo GetMachineInfo()
{
MachineInfo info = new MachineInfo();
return info;
}
/// <summary>
/// Open the logfile and read everything out of it
/// </summary>
private void ParseLog()
{
try
{
if (String.IsNullOrEmpty(fileToParse))
{
statusText = "You need to select an actual logfile to parse first.";
return;
}
allMachines.Clear();
NetgearWNDR4000 logUtil = new NetgearWNDR4000(fileToParse);
Regex matchString = new Regex(logUtil.RegexMatchString, RegexOptions.IgnoreCase);
if (logUtil.Fetch())
{
foreach (String line in logUtil.LogText)
{
// don't puke on a mismatch
try
{
Match match = matchString.Match(line);
if (match.Success)
{
MachineInfo mInfo = new MachineInfo(match.Groups[2].Value);
DateTime.TryParse(match.Groups[3].Value, out mInfo.LastSeen);
IPAddress.TryParse(match.Groups[1].Value, out mInfo.LastIP);
if (!allMachines.Contains(mInfo))
{
// we can cheat and reuse 'equals' here since the prototype matches what we need in a predicate
MachineInfo knownBox = knownMachines.Find(mInfo.Equals);
if (knownBox != null)
{
mInfo.Description = knownBox.Description;
knownBox.LastSeen = mInfo.LastSeen;
knownBox.LastIP = mInfo.LastIP;
}
else
{
RaiseAlert(mInfo.MACAddress);
}
allMachines.Add(mInfo);
}
}
}
catch (Exception ex)
{
// don't crash, just report the error
messages.Add(ex.Message);
}
}
statusText = String.Format("Logfile loaded successfully; last update {0}.", DateTime.Now.GetDateTimeFormats('u')[0]);
}
else
{
statusText = "Unable to parse logfile";
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error reading log", MessageBoxButton.OK, MessageBoxImage.Error);
statusText = "Unable to parse logfile";
}
UpdateMachineList();
}
public SelectGameResponse(MachineInfo mi)
{
machine = mi;
}
