diff --git a/ClientApp/ClientApp.csproj b/ClientApp/ClientApp.csproj index c66ed7c..d8ae036 100644 --- a/ClientApp/ClientApp.csproj +++ b/ClientApp/ClientApp.csproj @@ -9,7 +9,15 @@ + + + + + + + + \ No newline at end of file diff --git a/ClientApp/Utils/Client.cs b/ClientApp/Utils/Client.cs new file mode 100644 index 0000000..ac4ae99 --- /dev/null +++ b/ClientApp/Utils/Client.cs @@ -0,0 +1,292 @@ +using System; +using System.Linq; +using System.Net.Sockets; +using System.Text; +using ProftaakRH; + +namespace Client +{ + public class Client : IDataReceiver + { + private TcpClient client; + private NetworkStream stream; + private byte[] buffer = new byte[1024]; + private bool connected; + private byte[] totalBuffer = new byte[1024]; + private int totalBufferReceived = 0; + private EngineConnection engineConnection; + private bool sessionRunning = false; + private IHandler handler = null; + + + public Client() : this("localhost", 5555) + { + + } + + public Client(string adress, int port) + { + this.client = new TcpClient(); + this.connected = false; + client.BeginConnect(adress, port, new AsyncCallback(OnConnect), null); + } + + /// + /// initializes the VR engine and sets the callbacks + /// + private void initEngine() + { + engineConnection = EngineConnection.INSTANCE; + engineConnection.OnNoTunnelId = retryEngineConnection; + engineConnection.OnSuccessFullConnection = engineConnected; + if (!engineConnection.Connected) engineConnection.Connect(); + } + + /// + /// retries to connect to the VR engine if no tunnel id was found + /// + private void retryEngineConnection() + { + Console.WriteLine("-- Could not connect to the VR engine. Please make sure you are running the simulation!"); + Console.WriteLine("-- Press ENTER to retry connecting to the VR engine."); + Console.WriteLine("-- Press 'q' and then ENTER to not connect to the VR engine"); + string input = Console.ReadLine(); + if (input == string.Empty) engineConnection.CreateConnection(); + else + { + Console.WriteLine("Skipping connecting to VR engine..."); + engineConnection.Stop(); + } + + } + + private void engineConnected() + { + Console.WriteLine("successfully connected to VR engine"); + engineConnection.initScene(); + if (engineConnection.Connected && sessionRunning && !engineConnection.FollowingRoute) engineConnection.StartRouteFollow(); + } + + /// + /// callback method for when the TCP client is connected + /// + /// the result of the async read + private void OnConnect(IAsyncResult ar) + { + this.client.EndConnect(ar); + Console.WriteLine("TCP client Verbonden!"); + + + this.stream = this.client.GetStream(); + + tryLogin(); + + this.stream.BeginRead(this.buffer, 0, this.buffer.Length, new AsyncCallback(OnRead), null); + } + + /// + /// callback method for when there is a message read + /// + /// the result of the async read + private void OnRead(IAsyncResult ar) + { + int receivedBytes = this.stream.EndRead(ar); + + if (totalBufferReceived + receivedBytes > 1024) + { + throw new OutOfMemoryException("buffer too small"); + } + Array.Copy(buffer, 0, totalBuffer, totalBufferReceived, receivedBytes); + totalBufferReceived += receivedBytes; + + int expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0); + while (totalBufferReceived >= expectedMessageLength) + { + //volledig packet binnen + byte[] messageBytes = new byte[expectedMessageLength]; + Array.Copy(totalBuffer, 0, messageBytes, 0, expectedMessageLength); + + + byte[] payloadbytes = new byte[BitConverter.ToInt32(messageBytes, 0) - 5]; + + Array.Copy(messageBytes, 5, payloadbytes, 0, payloadbytes.Length); + + string identifier; + bool isJson = DataParser.getJsonIdentifier(messageBytes, out identifier); + if (isJson) + { + switch (identifier) + { + case DataParser.LOGIN_RESPONSE: + string responseStatus = DataParser.getResponseStatus(payloadbytes); + if (responseStatus == "OK") + { + Console.WriteLine("Username and password correct!"); + this.connected = true; + initEngine(); + } + else + { + Console.WriteLine($"login failed \"{responseStatus}\""); + tryLogin(); + } + break; + case DataParser.START_SESSION: + Console.WriteLine("Session started!"); + this.sessionRunning = true; + if (engineConnection.Connected && !engineConnection.FollowingRoute) engineConnection.StartRouteFollow(); + sendMessage(DataParser.getStartSessionJson()); + break; + case DataParser.STOP_SESSION: + Console.WriteLine("Stop session identifier"); + this.sessionRunning = false; + sendMessage(DataParser.getStopSessionJson()); + break; + case DataParser.SET_RESISTANCE: + Console.WriteLine("Set resistance identifier"); + if (this.handler == null) + { + Console.WriteLine("handler is null"); + sendMessage(DataParser.getSetResistanceResponseJson(false)); + } + else + { + this.handler.setResistance(DataParser.getResistanceFromJson(payloadbytes)); + sendMessage(DataParser.getSetResistanceResponseJson(true)); + } + break; + default: + Console.WriteLine($"Received json with identifier {identifier}:\n{Encoding.ASCII.GetString(payloadbytes)}"); + break; + } + } + else if (DataParser.isRawData(messageBytes)) + { + Console.WriteLine($"Received data: {BitConverter.ToString(payloadbytes)}"); + } + + totalBufferReceived -= expectedMessageLength; + expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0); + } + + this.stream.BeginRead(this.buffer, 0, this.buffer.Length, new AsyncCallback(OnRead), null); + + } + + /// + /// starts sending a message to the server + /// + /// the message to send + private void sendMessage(byte[] message) + { + stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null); + } + + /// + /// callback method for when a message is fully written to the server + /// + /// the async result representing the asynchronous call + private void OnWrite(IAsyncResult ar) + { + this.stream.EndWrite(ar); + } + + #region interface + //maybe move this to other place + /// + /// bpm method for receiving the BPM value from the bluetooth bike or the simulation + /// + /// the message + public void BPM(byte[] bytes) + { + if (!sessionRunning) + { + return; + } + if (bytes == null) + { + throw new ArgumentNullException("no bytes"); + } + byte[] message = DataParser.GetRawDataMessage(bytes); + + if (engineConnection.Connected && engineConnection.FollowingRoute) + { + engineConnection.BikeBPM = bytes[1]; + engineConnection.UpdateInfoPanel(); + } + + + this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null); + } + + /// + /// method for receiving the bike message from the bluetooth bike or the simulation + /// + /// the message + public void Bike(byte[] bytes) + { + if (!sessionRunning) + { + return; + } + if (bytes == null) + { + throw new ArgumentNullException("no bytes"); + } + byte[] message = DataParser.GetRawDataMessage(bytes); + switch (bytes[0]) + { + case 0x10: + + engineConnection.BikeSpeed = (bytes[4] | (bytes[5] << 8)) * 0.01f; + break; + case 0x19: + engineConnection.BikePower = (bytes[5]) | (bytes[6] & 0b00001111) << 8; + break; + } + if (engineConnection.Connected && engineConnection.FollowingRoute) + engineConnection.UpdateInfoPanel(); + + this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null); + } + + #endregion + + /// + /// wether or not the client stream is connected + /// + /// true if it's connected, false if not + public bool IsConnected() + { + return this.connected; + } + /// + /// tries to log in to the server by asking for a username and password + /// + private void tryLogin() + { + //TODO File in lezen + Console.WriteLine("enter username"); + string username = Console.ReadLine(); + Console.WriteLine("enter password"); + string password = Console.ReadLine(); + + string hashUser = Hashing.Hasher.HashString(username); + string hashPassword = Hashing.Hasher.HashString(password); + + byte[] message = DataParser.getJsonMessage(DataParser.GetLoginJson(hashUser, hashPassword)); + + + this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null); + } + + /// + /// sets the handler for the client, so either the bike simulator or the bluetooth bike handler + /// + /// + public void setHandler(IHandler handler) + { + this.handler = handler; + } + } +} diff --git a/ClientApp/Utils/DataParser.cs b/ClientApp/Utils/DataParser.cs new file mode 100644 index 0000000..8eddb4c --- /dev/null +++ b/ClientApp/Utils/DataParser.cs @@ -0,0 +1,206 @@ +using Newtonsoft.Json; +using Newtonsoft.Json.Serialization; +using System; +using System.Globalization; +using System.Linq; +using System.Runtime.InteropServices.WindowsRuntime; +using System.Text; + +namespace Client +{ + public class DataParser + { + public const string LOGIN = "LOGIN"; + public const string LOGIN_RESPONSE = "LOGIN RESPONSE"; + public const string START_SESSION = "START SESSION"; + public const string STOP_SESSION = "STOP SESSION"; + public const string SET_RESISTANCE = "SET RESISTANCE"; + /// + /// makes the json object with LOGIN identifier and username and password + /// + /// username + /// password + /// json object to ASCII to bytes + public static byte[] GetLoginJson(string mUsername, string mPassword) + { + dynamic json = new + { + identifier = LOGIN, + data = new + { + username = mUsername, + password = mPassword, + } + }; + + return Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(json)); + } + + public static bool GetUsernamePassword(byte[] jsonbytes, out string username, out string password) + { + dynamic json = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(jsonbytes)); + try + { + username = json.data.username; + password = json.data.password; + return true; + } + catch + { + username = null; + password = null; + return false; + } + } + + private static byte[] getJsonMessage(string mIdentifier, dynamic data) + { + dynamic json = new + { + identifier = mIdentifier, + data + }; + return getMessage(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(json)), 0x01); + } + + private static byte[] getJsonMessage(string mIdentifier) + { + dynamic json = new + { + identifier = mIdentifier, + }; + return getMessage(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(json)), 0x01); + } + + public static byte[] getLoginResponse(string mStatus) + { + return getJsonMessage(LOGIN_RESPONSE, new { status = mStatus }); + } + + public static string getResponseStatus(byte[] json) + { + return ((dynamic)JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json))).data.status; + } + + /// + /// get the identifier from json + /// + /// json in ASCII + /// gets the identifier + /// if it sucseeded + public static bool getJsonIdentifier(byte[] bytes, out string identifier) + { + if (bytes.Length <= 5) + { + throw new ArgumentException("bytes to short"); + } + byte messageId = bytes[4]; + + if (messageId == 0x01) + { + dynamic json = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(bytes.Skip(5).ToArray())); + identifier = json.identifier; + return true; + } + else + { + identifier = ""; + return false; + } + } + + /// + /// checks if the de message is raw data according to the protocol + /// + /// message + /// if message contains raw data + public static bool isRawData(byte[] bytes) + { + if (bytes.Length <= 5) + { + throw new ArgumentException("bytes to short"); + } + return bytes[4] == 0x02; + } + + /// + /// constructs a message with the payload, messageId and clientId + /// + /// + /// + /// + /// the message ready for sending + private static byte[] getMessage(byte[] payload, byte messageId) + { + byte[] res = new byte[payload.Length + 5]; + + Array.Copy(BitConverter.GetBytes(payload.Length + 5), 0, res, 0, 4); + res[4] = messageId; + Array.Copy(payload, 0, res, 5, payload.Length); + + return res; + } + + /// + /// constructs a message with the payload and clientId and assumes the payload is raw data + /// + /// + /// + /// the message ready for sending + public static byte[] GetRawDataMessage(byte[] payload) + { + return getMessage(payload, 0x02); + } + + /// + /// constructs a message with the payload and clientId and assumes the payload is json + /// + /// + /// + /// the message ready for sending + public static byte[] getJsonMessage(byte[] payload) + { + return getMessage(payload, 0x01); + } + + public static byte[] getStartSessionJson() + { + return getJsonMessage(START_SESSION); + } + + public static byte[] getStopSessionJson() + { + return getJsonMessage(STOP_SESSION); + } + + public static byte[] getSetResistanceJson(float mResistance) + { + dynamic data = new + { + resistance = mResistance + }; + return getJsonMessage(SET_RESISTANCE, data); + } + + public static byte[] getSetResistanceResponseJson(bool mWorked) + { + dynamic data = new + { + worked = mWorked + }; + return getJsonMessage(SET_RESISTANCE, data); + } + + public static float getResistanceFromJson(byte[] json) + { + return ((dynamic)JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json))).data.resistance; + } + + public static bool getResistanceFromResponseJson(byte[] json) + { + return ((dynamic)JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json))).data.worked; + } + + + } +} diff --git a/ClientApp/Utils/EngineConnection.cs b/ClientApp/Utils/EngineConnection.cs new file mode 100644 index 0000000..9d0d4e5 --- /dev/null +++ b/ClientApp/Utils/EngineConnection.cs @@ -0,0 +1,313 @@ +using System; +using System.Collections.Generic; +using System.Text; +using RH_Engine; +using System.Net.Sockets; + +namespace Client +{ + public delegate void HandleSerial(string message); + public delegate void HandleNoTunnelId(); + public delegate void OnSuccessfullConnection(); + + public sealed class EngineConnection + { + private static EngineConnection instance = null; + private static readonly object padlock = new object(); + public HandleNoTunnelId OnNoTunnelId; + public OnSuccessfullConnection OnSuccessFullConnection; + + + private static PC[] PCs = { + //new PC("DESKTOP-M2CIH87", "Fabian"), + //new PC("T470S", "Shinichi"), + //new PC("DESKTOP-DHS478C", "semme"), + new PC("HP-ZBOOK-SEM", "Sem") + //new PC("DESKTOP-TV73FKO", "Wouter"), + //new PC("DESKTOP-SINMKT1", "Ralf van Aert"), + //new PC("NA", "Bart") + }; + + private static ServerResponseReader serverResponseReader; + private static string sessionId = string.Empty; + private static string tunnelId = string.Empty; + private static string cameraId = string.Empty; + private static string routeId = string.Empty; + private static string panelId = string.Empty; + private static string bikeId = string.Empty; + private static string headId = string.Empty; + + public float BikeSpeed { get; set; } + public float BikePower { get; set; } + public float BikeBPM { get; set; } + public float BikeResistance { get; set; } + + public bool FollowingRoute = false; + + private static NetworkStream stream; + + private static Dictionary serialResponses = new Dictionary(); + private Command mainCommand; + + public bool Connected = false; + + EngineConnection() + { + BikeSpeed = 0; + BikePower = 0; + BikeBPM = 0; + BikeResistance = 50; + } + + /// + /// Singleton constructor + /// + public static EngineConnection INSTANCE + { + get + { + lock (padlock) + { + if (instance == null) + { + instance = new EngineConnection(); + } + } + return instance; + } + } + + + + /// + /// connects to the vr engine and initalizes the serverResponseReader + /// + public void Connect() + { + TcpClient client = new TcpClient("145.48.6.10", 6666); + stream = client.GetStream(); + initReader(); + CreateConnection(); + } + + /// + /// initializes and starts the reading of the responses from the vr server + /// + /// the networkstream + private void initReader() + { + serverResponseReader = new ServerResponseReader(stream); + serverResponseReader.callback = HandleResponse; + serverResponseReader.StartRead(); + } + + #region VR Message traffic + /// + /// connects to the server and creates the tunnel + /// + /// the network stream to use + public void CreateConnection() + { + + WriteTextMessage( "{\r\n\"id\" : \"session/list\",\r\n\"serial\" : \"list\"\r\n}"); + + // wait until we have got a sessionId + while (sessionId == string.Empty) { } + + string tunnelCreate = "{\"id\" : \"tunnel/create\", \"data\" : {\"session\" : \"" + sessionId + "\"}}"; + + WriteTextMessage(tunnelCreate); + + + } + + /// + /// callback method that handles responses from the server + /// + /// the response message from the server + public void HandleResponse(string message) + { + string id = JSONParser.GetID(message); + + // because the first messages don't have a serial, we need to check on the id + if (id == "session/list") + { + sessionId = JSONParser.GetSessionID(message, PCs); + } + else if (id == "tunnel/create") + { + tunnelId = JSONParser.GetTunnelID(message); + Console.WriteLine("set tunnel id to " + tunnelId); + if (tunnelId == null) + { + Write("could not find a valid tunnel id!"); + OnNoTunnelId?.Invoke(); + Connected = false; + FollowingRoute = false; + return; + } else + { + Write("got tunnel id! " + tunnelId); + Connected = true; + OnSuccessFullConnection?.Invoke(); + } + } + + if (message.Contains("serial")) + { + //Console.WriteLine("GOT MESSAGE WITH SERIAL: " + message + "\n\n\n"); + string serial = JSONParser.GetSerial(message); + //Console.WriteLine("Got serial " + serial); + if (serialResponses.ContainsKey(serial)) serialResponses[serial].Invoke(message); + } + } + + public void initScene() + { + Write("initializing scene..."); + mainCommand = new Command(tunnelId); + + // reset the scene + WriteTextMessage(mainCommand.ResetScene()); + + //Get sceneinfo and set the id's + SendMessageAndOnResponse(mainCommand.GetSceneInfoCommand("sceneinfo"), "sceneinfo", + (message) => + { + //Console.WriteLine("\r\n\r\n\r\nscene info" + message); + cameraId = JSONParser.GetIdSceneInfoChild(message, "Camera"); + string headId = JSONParser.GetIdSceneInfoChild(message, "Head"); + string handLeftId = JSONParser.GetIdSceneInfoChild(message, "LeftHand"); + string handRightId = JSONParser.GetIdSceneInfoChild(message, "RightHand"); + + //Force(stream, mainCommand.DeleteNode(handLeftId, "deleteHandL"), "deleteHandL", (message) => Console.WriteLine("Left hand deleted")); + //Force(stream, mainCommand.DeleteNode(handRightId, "deleteHandR"), "deleteHandR", (message) => Console.WriteLine("Right hand deleted")); + }); + // add the route and set the route id + SendMessageAndOnResponse(mainCommand.RouteCommand("routeID"), "routeID", (message) => routeId = JSONParser.GetResponseUuid(message)); + } + + internal void StartRouteFollow() + { + Write("Starting route follow..."); + FollowingRoute = true; + + SendMessageAndOnResponse(mainCommand.AddBikeModel("bikeID"), "bikeID", + (message) => + { + bikeId = JSONParser.GetResponseUuid(message); + SendMessageAndOnResponse(mainCommand.addPanel("panelAdd", bikeId), "panelAdd", + (message) => + { + + panelId = JSONParser.getPanelID(message); + + WriteTextMessage(mainCommand.ColorPanel(panelId)); + UpdateInfoPanel(); + + while (cameraId == string.Empty) { } + SetFollowSpeed(5.0f); + }); + }); + } + + public void UpdateInfoPanel() + { + ShowPanel(BikeSpeed, (int)BikeBPM, (int)BikePower, (int)BikeResistance); + WriteTextMessage(mainCommand.RouteSpeed(BikeSpeed, bikeId)); + WriteTextMessage(mainCommand.RouteSpeed(BikeSpeed, cameraId)); + } + + public void ShowPanel(double bikeSpeed, int bpm, int power, int resistance) + { + WriteTextMessage(mainCommand.ClearPanel(panelId)); + + SendMessageAndOnResponse(mainCommand.showBikespeed(panelId, "bikeSpeed", bikeSpeed), "bikeSpeed", + (message) => + { + // TODO check if is drawn + }); + SendMessageAndOnResponse(mainCommand.showHeartrate(panelId, "bpm", bpm), "bpm", + (message) => + { + // TODO check if is drawn + }); + SendMessageAndOnResponse(mainCommand.showPower(panelId, "power", power), "power", + (message) => + { + // TODO check if is drawn + }); + SendMessageAndOnResponse(mainCommand.showResistance(panelId, "resistance", resistance), "resistance", + (message) => + { + // TODO check if is drawn + }); + + // Check if every text is drawn! + + WriteTextMessage(mainCommand.SwapPanel(panelId)); + } + + private void SetFollowSpeed(float speed) + { + WriteTextMessage(mainCommand.RouteFollow(routeId, bikeId, speed, new float[] { 0, -(float)Math.PI / 2f, 0 }, new float[] { 0, 0, 0 })); + WriteTextMessage(mainCommand.RouteFollow(routeId, cameraId, speed)); + } + + #endregion + + #region message send/receive + + /// + /// method that sends the speciefied message with the specified serial, and executes the given action upon receivind a reply from the server with this serial. + /// + /// the networkstream to use + /// the message to send + /// the serial to check for + /// the code to be executed upon reveiving a reply from the server with the specified serial + public void SendMessageAndOnResponse(string message, string serial, HandleSerial action) + { + if (serialResponses.ContainsKey(serial)) + { + serialResponses[serial] = action; + } else + { + serialResponses.Add(serial, action); + } + WriteTextMessage(message); + } + + /// + /// writes a message to the server + /// + /// the network stream to use + /// the message to send + public void WriteTextMessage(string message) + { + byte[] msg = Encoding.ASCII.GetBytes(message); + byte[] res = new byte[msg.Length + 4]; + + Array.Copy(BitConverter.GetBytes(msg.Length), 0, res, 0, 4); + Array.Copy(msg, 0, res, 4, msg.Length); + + stream.Write(res); + + //Write("sent message " + message); + } + + #endregion + + public void Stop() + { + serverResponseReader.Stop(); + + } + public void Write(string msg) + { + Console.WriteLine( "[ENGINECONNECT] " + msg); + } + + } + + +} diff --git a/ClientApp/Utils/Program.cs b/ClientApp/Utils/Program.cs new file mode 100644 index 0000000..289bcd4 --- /dev/null +++ b/ClientApp/Utils/Program.cs @@ -0,0 +1,42 @@ +using System; +using Hardware; +using Hardware.Simulators; +using RH_Engine; +using System.Security.Cryptography; +using System.Text; + +namespace Client +{ + class Program + { + //static void Main(string[] args) + //{ + // Console.WriteLine("// Connecting... //"); + // //connect fiets? + + // Client client = new Client(); + + + // while (!client.IsConnected()) + // { + + // } + // //BLEHandler bLEHandler = new BLEHandler(client); + + // //bLEHandler.Connect(); + + // //client.setHandler(bLEHandler); + + + // BikeSimulator bikeSimulator = new BikeSimulator(client); + + // bikeSimulator.StartSimulation(); + + // client.setHandler(bikeSimulator); + + // while (true) + // { + // } + //} + } +} diff --git a/ClientApp/Views/MainWindow.xaml.cs b/ClientApp/Views/MainWindow.xaml.cs index 4ae4a80..49d8058 100644 --- a/ClientApp/Views/MainWindow.xaml.cs +++ b/ClientApp/Views/MainWindow.xaml.cs @@ -13,6 +13,9 @@ using System.Windows.Media; using System.Windows.Media.Imaging; using System.Windows.Navigation; using System.Windows.Shapes; +using ClientApp.Utils; +using Hardware.Simulators; +using Client; namespace ClientApp { @@ -25,6 +28,24 @@ namespace ClientApp { InitializeComponent(); DataContext = new MainWindowViewModel(); + + Client client = new Client(); + while (!client.IsConnected()) + { + + } + //BLEHandler bLEHandler = new BLEHandler(client); + + //bLEHandler.Connect(); + + //client.setHandler(bLEHandler); + + + BikeSimulator bikeSimulator = new BikeSimulator(client); + + bikeSimulator.StartSimulation(); + + client.setHandler(bikeSimulator); } } } diff --git a/ProftaakRH/ProftaakRH.sln b/ProftaakRH/ProftaakRH.sln index e2bf4ce..b96b151 100644 --- a/ProftaakRH/ProftaakRH.sln +++ b/ProftaakRH/ProftaakRH.sln @@ -17,10 +17,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DokterApp", "..\DokterApp\D EndProject Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Hashing", "..\Hashing\Hashing.shproj", "{70277749-D423-4871-B692-2EFC5A6ED932}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ClientApp", "..\ClientApp\ClientApp.csproj", "{013AADBA-1D27-4A52-81D8-217697E91039}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ClientApp", "..\ClientApp\ClientApp.csproj", "{013AADBA-1D27-4A52-81D8-217697E91039}" EndProject Global GlobalSection(SharedMSBuildProjectFiles) = preSolution + ..\Hashing\Hashing.projitems*{013aadba-1d27-4a52-81d8-217697e91039}*SharedItemsImports = 5 ..\Hashing\Hashing.projitems*{5759dd20-7a4f-4d8d-b986-a70a7818c112}*SharedItemsImports = 5 ..\Hashing\Hashing.projitems*{70277749-d423-4871-b692-2efc5a6ed932}*SharedItemsImports = 13 ..\Hashing\Hashing.projitems*{b1ab6f51-a20d-4162-9a7f-b3350b7510fd}*SharedItemsImports = 5