public PassageData GetStatistic(string authToken, string passageGuid)
        {
            bool tokenExists = AuthRepository.IsTokenExist(authToken);

            //#if DEBUG
            //            tokenExists = true;
            //#endif
            if (!tokenExists || passageGuid == null)
            {
                return(new PassageData());
            }

            string login = AuthRepository.GetLogin(authToken);
            var    guid  = new Guid(passageGuid);

            if (_passages.ContainsKey(guid))
            {
                return(_passages[guid]);
            }
            _passages.Add(guid, new PassageData());
            using (var context = new PP_testEntities())
            {
                var user     = context.Uzytkownicies.First(u => u.email == login);
                var przejazd = context.Przejazdy_fs.FirstOrDefault(p => p.id_przejazdu == guid);
                if (przejazd == null || przejazd.id_uzytk != user.id_uzytk && !user.administrator)
                {
                    return(new PassageData());
                }

                string fileName    = DateTime.Now.ToString("yyyyMMddHHmmtt") + ReadingsRepository.RandomString(5);
                string tmpFilePath = Path.Combine(Path.GetTempPath(), fileName);
                File.WriteAllBytes(tmpFilePath, przejazd.dane_przejazdu);
                var result = _passages[guid];
                using (var con = new SQLiteConnection("Data Source=" + tmpFilePath))
                {
                    con.Open();

                    string cmdstr = "SELECT * FROM location_data ORDER BY TIMESTAMP";
                    using (var cmd = new SQLiteCommand(cmdstr, con))
                    {
                        using (SQLiteDataReader rdr = cmd.ExecuteReader())
                        {
                            long   timestamp;
                            double lat, lng;
                            while (rdr.Read())
                            {
                                timestamp = rdr.GetInt64(1);
                                lat       = rdr.GetDouble(2);
                                lng       = rdr.GetDouble(3);
                                result.LocationTimestamp.Add(timestamp);
                                result.LocationLat.Add(lat);
                                result.LocationLng.Add(lng);
                            }
                        }
                    }

                    cmdstr = "SELECT * FROM accelerometer_data ORDER BY TIMESTAMP";
                    using (var cmd = new SQLiteCommand(cmdstr, con))
                    {
                        using (SQLiteDataReader rdr = cmd.ExecuteReader())
                        {
                            long   timestamp;
                            double x, y, z;
                            while (rdr.Read())
                            {
                                timestamp = rdr.GetInt64(1);
                                x         = rdr.GetDouble(2);
                                y         = rdr.GetDouble(3);
                                z         = rdr.GetDouble(4);
                                result.AccTimestamp.Add(timestamp);
                                result.AccX.Add(x);
                                result.AccY.Add(y);
                                result.AccZ.Add(z);
                            }
                        }
                    }

                    cmdstr = "SELECT * FROM gyroscope_data ORDER BY TIMESTAMP";
                    using (var cmd = new SQLiteCommand(cmdstr, con))
                    {
                        using (SQLiteDataReader rdr = cmd.ExecuteReader())
                        {
                            long   timestamp;
                            double x, y, z;
                            while (rdr.Read())
                            {
                                timestamp = rdr.GetInt64(1);
                                x         = rdr.GetDouble(2);
                                y         = rdr.GetDouble(3);
                                z         = rdr.GetDouble(4);
                                result.GyroTimestamp.Add(timestamp);
                                result.GyroX.Add(x);
                                result.GyroY.Add(y);
                                result.GyroZ.Add(z);
                            }
                        }
                    }

                    cmdstr = "SELECT * FROM light_data ORDER BY TIMESTAMP";
                    using (var cmd = new SQLiteCommand(cmdstr, con))
                    {
                        using (SQLiteDataReader rdr = cmd.ExecuteReader())
                        {
                            long   timestamp;
                            double intensity;
                            while (rdr.Read())
                            {
                                timestamp = rdr.GetInt64(1);
                                intensity = rdr.GetDouble(2);
                                result.LightTimestamp.Add(timestamp);
                                result.LightIntensity.Add(intensity);
                            }
                        }
                    }
                }
                File.Delete(tmpFilePath);

                return(result);
            }
        }
        public PassageData SplitPassageData(UpdateStatistic stat)
        {
            bool tokenExists = AuthRepository.IsTokenExist(stat.Token);

            //#if DEBUG
            //            tokenExists = true;
            //#endif
            if (!tokenExists || stat.PassageGuid == null)
            {
                return(new PassageData());
            }

            string login = AuthRepository.GetLogin(stat.Token);
            var    guid  = new Guid(stat.PassageGuid);

            using (var context = new PP_testEntities())
            {
                var user     = context.Uzytkownicies.First(u => u.email == login);
                var przejazd = context.Przejazdy_fs.FirstOrDefault(p => p.id_przejazdu == guid);
                if (przejazd == null || przejazd.id_uzytk != user.id_uzytk && !user.administrator)
                {
                    return(new PassageData());
                }

                string fileNameInner    = DateTime.Now.ToString("yyyyMMddHHmmtt") + ReadingsRepository.RandomString(5);
                string fileNameOuter    = DateTime.Now.ToString("yyyyMMddHHmmtt") + ReadingsRepository.RandomString(5);
                string tmpFilePathInner = Path.Combine(Path.GetTempPath(), fileNameInner);
                string tmpFilePathOuter = Path.Combine(Path.GetTempPath(), fileNameOuter);
                File.WriteAllBytes(tmpFilePathInner, przejazd.dane_przejazdu);
                File.WriteAllBytes(tmpFilePathOuter, przejazd.dane_przejazdu);

                var nowy_przejazd = new Przejazdy_fs();
                using (var con = new SQLiteConnection("Data Source=" + tmpFilePathInner))
                    using (var con2 = new SQLiteConnection("Data Source=" + tmpFilePathOuter))
                    {
                        con.Open();
                        con2.Open();

                        string query =
                            $"DELETE FROM location_data where TIMESTAMP >= {stat.StartTimestamp} and TIMESTAMP <= {stat.EndTimestamp}";
                        SQLiteCommand cmd = new SQLiteCommand(query, con2);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();

                        query = $"DELETE FROM accelerometer_data where TIMESTAMP >= {stat.StartTimestamp} and TIMESTAMP <= {stat.EndTimestamp}";
                        cmd   = new SQLiteCommand(query, con2);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();

                        query = $"DELETE FROM gyroscope_data where TIMESTAMP >= {stat.StartTimestamp} and TIMESTAMP <= {stat.EndTimestamp}";
                        cmd   = new SQLiteCommand(query, con2);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();

                        query = $"DELETE FROM light_data where TIMESTAMP >= {stat.StartTimestamp} and TIMESTAMP <= {stat.EndTimestamp}";
                        cmd   = new SQLiteCommand(query, con2);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();


                        query =
                            $"DELETE FROM location_data where TIMESTAMP < {stat.StartTimestamp} or TIMESTAMP > {stat.EndTimestamp}";
                        cmd = new SQLiteCommand(query, con);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();

                        query = $"DELETE FROM accelerometer_data where TIMESTAMP < {stat.StartTimestamp} or TIMESTAMP > {stat.EndTimestamp}";
                        cmd   = new SQLiteCommand(query, con);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();

                        query = $"DELETE FROM gyroscope_data where TIMESTAMP < {stat.StartTimestamp} or TIMESTAMP > {stat.EndTimestamp}";
                        cmd   = new SQLiteCommand(query, con);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();

                        query = $"DELETE FROM light_data where TIMESTAMP < {stat.StartTimestamp} or TIMESTAMP > {stat.EndTimestamp}";
                        cmd   = new SQLiteCommand(query, con);
                        cmd.ExecuteNonQuery();
                        cmd.Dispose();

                        context.Tagis.RemoveRange(context.Tagis.Where(t => t.id_przejazdu == guid));
                        var repo = new ReadingsRepository();
                        repo.AddTagsToRide(con2, context, przejazd);

                        nowy_przejazd.id_przejazdu   = Guid.NewGuid();
                        nowy_przejazd.id_pojazdu     = przejazd.id_pojazdu;
                        nowy_przejazd.id_uzytk       = przejazd.id_uzytk;
                        nowy_przejazd.data_przejazdu = przejazd.data_przejazdu;
                        repo.AddTagsToRide(con, context, nowy_przejazd);
                    }
                przejazd.dane_przejazdu      = File.ReadAllBytes(tmpFilePathOuter);
                nowy_przejazd.dane_przejazdu = File.ReadAllBytes(tmpFilePathInner);
                File.Delete(tmpFilePathOuter);
                File.Delete(tmpFilePathInner);
                context.Przejazdy_fs.Add(nowy_przejazd);
                context.SaveChanges();

                return(new PassageData());
            }
        }