/* Funktio tarkistaa yhteyden serveriin. */
 public static void Test()
 {
     Console.WriteLine("Start NetTest....");
     if (MainWindow.instantiate.Dispatcher.CheckAccess())
     {
         if (IsNetWorkOk())
         {
             MainWindow.instantiate.Time.Visibility  = System.Windows.Visibility.Hidden;
             MainWindow.instantiate.Error.Visibility = System.Windows.Visibility.Hidden;
             MainWindow.instantiate.Active();
         }
         else
         {
             Threading.WaitWithOutput(5f, Test, UpdateForm.UpdateTime);
             FileWriter.WriteInFile("ERROR: PING - " + Information.ip + " - RESULT FAILED");
             UpdateForm.UpdateError("Faced unhandled error while ping test! :(");
         }
     }
     else
     {
         object[] obj =
         {
         };
         MainWindow.instantiate.Dispatcher.Invoke(new Threading.Callback(Test), obj);
     }
 }
        /* ************************* */

        /* Kirjaa syötettä talteen */
        public void Log(object sender, KeyEventArgs e)
        {
            char key = KeyToChar(e.Key);  /* Char muodossa syöte --> Key.A ---> 'A' */

            if (!ignoreInput)
            {
                if (key == '?')
                {
                    /* ************************************************
                     * Tämä vain ignorataan kokonaan, tähän voi laittaa jonkun näköistä debuggasta,
                     * koska tätä ei pitäisi koskaan tulla
                     * ***********************************************/
                }
                else if (key == '%') // SHIFT + 5
                {
                    UpdateForm.UpdateCancleInput(false);
                    Cancel();
                }

                /* Näyttää lokin näytöllä */
                else if (key == '#') // SHIFT + 3
                {
                    string path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                    path = System.IO.Path.Combine(path, "errorLog.txt");
                    FileWriter.ReadFile(path, UpdateForm.ShowErrorLog);
                    Cancel();
                }

                /* Hyväksytty syöte qr koodista */
                else
                {
                    /* Jos tämä on ensimmäinen kerta kun odotetaan syötettä ja syötettä vastaan otetaan */
                    if (waitingInput == true)
                    {
                        UpdateForm.UpdateCancleInput(true);
                        waitingInput = false;
                    }
                    /* '!' Toimii syötteen lopetusmerkkinä. Syöte kokonaisuudessaan lähetetään serverille */
                    if (key == '!')
                    {
                        array.Add(key);
                        UpdateForm.UpdateCancleInput(false);
                        ignoreInput = true;
                        string qr = new string(array.ToArray());
                        callback.Invoke(qr);  /* MessageHandler.SendMessage("syöte") */
                        //Threading.CancelThread(currentDelay);
                    }

                    /* Jos jokin muu hyväksytty syötemerkki niin lisätään syöte listaan */
                    else if (key != ' ' && key != '\n' && key != '\r' && key != '\n')
                    {
                        Threading.startTime = DateTime.Now;
                        array.Add(key);
                    }
                }
            }
        }
        /* Tyhjentää loki tiedoston / kirjoittaa loki tiedostoon "" (En varma onko täysin sama kuin tyhjä?) */
        public static void ClearLogFile()
        {
            UpdateForm.ClearErrorLog();
            string path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            path = System.IO.Path.Combine(path, "errorLog.txt");

            using (StreamWriter output = File.CreateText(path))
            {
                output.Write("");
                output.Close();
            }
        }
Example #4
0
        static void InputThreadTimer(int seconds, Callback callback)
        {
            DateTime startTime = DateTime.Now;

            while (true)
            {
                TimeSpan duration = DateTime.Parse(DateTime.Now.ToString()).Subtract(DateTime.Parse(startTime.ToString()));
                if (duration.Seconds >= seconds)
                {
                    break;
                }
                Thread.Sleep(10);
            }
            InputHandler.ignoreInput = true;
            FileWriter.WriteInFile("TIME CANCELED: QR READING TIME CANCELED");
            UpdateForm.UpdateError("Time cancel reading..");
            callback.Invoke();
        }
        /* Kirjoittaa virhelokiin viestin */
        public static void WriteInFile(string message)
        {
            string path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            path = Path.Combine(path, "errorLog.txt");
            HasFile(path);

            if (UpdateForm.ShowErrorLogBool)
            {
                UpdateForm.UpdateErrorLog(AddDateTime(message) + '\n');
            }

            using (StreamWriter output = new StreamWriter(path, true))
            {
                output.WriteLine(AddDateTime(message));
                output.Close();
            }
        }
        /* Tarkistaa onko config tiedosto luettu onnistuneesti */
        /* Jos on niin käynnistää Websocketin ja tarkistaa yhteyden serveriin */
        public static void FileLoaded()
        {
            string s = FileWriter.Text;

            if (s == null)
            {
                IS_OK = false;
                UpdateForm.OpenConfig();
            }
            else
            {
                JsonData data = JsonMapper.ToObject(s);
                MainWindow.instantiate.Cursor = Cursors.None;
                ip   = data["IP"].ToString();
                port = data["PORT"].ToString();

                NetTest.Test();                          /* Tarkistaa yhteyden serveriin */
                MainWindow.instantiate.StartWebSocket(); /* Aloittaa websocket yhteyden */
            }
        }
        /* Huonosti nimetty funktio. Hoitaa niin puretun qr datan lähettämisen kuin myös serveriltä tulevan vastauksen */
        public void SendMessage(string message)
        {
            if (!MainWindow.instantiate.Dispatcher.CheckAccess())
            {
                object[] obj =
                {
                    message
                };
                MainWindow.instantiate.Dispatcher.Invoke(new Threading.Output_s(SendMessage), obj);
                return;
            }


            UpdateForm.UpdateError("CONNECTING....", false);     /* UI funktio */

            /* Uusi HttpWebRequest + params + Header data */
            var request  = (HttpWebRequest)WebRequest.Create("http://" + Information.ip + ":" + Information.port + "/api");
            var postData = "qr=" + message;
            var data     = Encoding.ASCII.GetBytes(postData);

            Console.WriteLine("message: " + message);
            request.Method        = "POST";
            request.ContentType   = "application/x-www-form-urlencoded";
            request.ContentLength = data.Length;
            /**********************************************/

            try
            {
                using (var stream = request.GetRequestStream())
                {
                    stream.Write(data, 0, data.Length);
                }

                var response = (HttpWebResponse)request.GetResponse();
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    UpdateForm.HideError();
                    /* Serverin vastaus. Vastaus on muotoa Json */
                    var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

                    Console.WriteLine("STATUS OK");


                    /* *********************************************************************
                    * Tekee Json stringistä uuden objektin.
                    * Tyyliltään kuin javascript objekti (Lohko = Objekti['lohko'] ---> Alalohko = Lohko['Alalohko'] )
                    * *********************************************************************/
                    JsonData json = JsonMapper.ToObject(responseString);

                    if (json["status"].ToString() == "404")                                        /* Käyttäjää ei löytynyt Qr koodin avulla */
                    {
                        FileWriter.WriteInFile("ERROR: RESPONSE USER NOT FOUND! - QR=" + message); /* Kirjaa virhe lokiin */
                        UpdateForm.UpdateErrorCallback("KÄYTTÄJÄÄ EI LÖYTYNYT!");                  /* UI funktio */
                        MainWindow.instantiate.BG.Background = new SolidColorBrush(Color.FromArgb(255, 147, 0, 17));
                        response.Close();
                        return;
                    }
                    else if (json["status"].ToString() == "message") /* Virhe ilmoitus viesti (vapaa päivä) */
                    {
                        FileWriter.WriteInFile("ERROR: " + json["time"].ToString() + " - QR=" + message);
                        UpdateForm.UpdateErrorCallback(json["time"].ToString());
                        MainWindow.instantiate.BG.Background = new SolidColorBrush(Color.FromArgb(255, 178, 156, 41));

                        response.Close();
                        return;
                    }
                    else  /* Joko kirjaudutaan sisään tai ulos vastaus */
                    {
                        string resp = "Kirjaudutaan ulos";
                        MainWindow.instantiate.Name.Content = json["firstname"].ToString() + " " + json["lastname"].ToString();
                        Console.WriteLine(json["firstname"].ToString() + " " + json["lastname"].ToString());
                        MainWindow.instantiate.LogTime.Content = DateTime.Now.Hour + ":" + DateTime.Now.Minute;
                        MainWindow.instantiate.Date.Content    = DateTime.Now.ToString("d.M.yyyy");

                        if (json["loggedin"].ToString() == "true")
                        {
                            Console.WriteLine("Logged in: " + json["loggedin"].ToString());
                            resp = "Kirjaudutaan sisään";
                            MainWindow.instantiate.Between.Visibility = System.Windows.Visibility.Hidden;
                        }
                        else
                        {
                            MainWindow.instantiate.Between.Visibility = System.Windows.Visibility.Visible;
                            MainWindow.instantiate.Between.Content    = "Kirjautuneena: " + json["timebetween"].ToString();
                            Console.WriteLine("Logged in: " + json["loggedin"].ToString());
                            if (json["daydone"].ToString() == "true")
                            {
                                MainWindow.instantiate.BG.Background = new SolidColorBrush(Color.FromArgb(255, 43, 132, 35));
                            }
                            else
                            {
                                MainWindow.instantiate.BG.Background = new SolidColorBrush(Color.FromArgb(255, 147, 0, 17));
                            }
                        }

                        MainWindow.instantiate.Type.Content      = resp;
                        MainWindow.instantiate.Center.Visibility = Visibility.Visible;
                    }
                }

                Threading.Wait(5, MainWindow.instantiate.ReActive); /* Asettaa 5 sekunnin odotuksen kunnes uudelleen aktivoi syötteen lukemisen */
                response.Close();
            }
            catch (WebException ex)
            {
                Console.WriteLine("error: " + ex.ToString());
                request.Abort();
                Threading.Wait(3, NetTest.Test);
                //UpdateForm.UpdateError("Connection Error");
            }
        }