public async Task DeleteRecord(Record record)
        {
            using (var db = new PrototypingContext())
            {
                Record findRecord = db.Records.Single(r => r.RecordId == record.RecordId);
                await db.Entry(findRecord).Reference(r => r.User).LoadAsync();

                User userParent = findRecord.User;
                await db.Entry(userParent).Reference(u => u.Prototype).LoadAsync();

                try
                {
                    StorageFolder prototypeFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync(userParent.Prototype.Name + "_" + userParent.PrototypeId);

                    StorageFolder userFolder = await prototypeFolder.GetFolderAsync(userParent.Name + "_" + userParent.UserId);

                    StorageFolder recordFolder = await userFolder.GetFolderAsync("Record_" + findRecord.RecordId);

                    await recordFolder.DeleteAsync();
                }
                catch (System.IO.FileNotFoundException)
                {
                    System.Diagnostics.Debug.WriteLine("Prototype/User folder not found");
                }

                db.Records.Remove(findRecord);
                db.SaveChanges();
            }
            UpdateRecordList(record.UserId);
        }
        public async Task LoadData(int _userId)
        {
            userId   = _userId;
            _webview = new Windows.UI.Xaml.Controls.WebView();
            _webview.Settings.IsJavaScriptEnabled = true;
            _webview.NavigationStarting          += WebView_NavigationStarting;
            _webview.NavigationFailed            += Webview_NavigationFailed;
            _webview.NavigationCompleted         += WebView_NavigationCompleted;
            _webview.ScriptNotify += WebView_ScriptNotify;

            using (var db = new PrototypingContext())
            {
                User user = db.Users.Single(u => u.UserId == userId);
                db.Entry(user).Reference(u => u.Prototype).Load();
                recordSettings = db.RecordSettings.Last();

                WebView.Navigate(new Uri(user.Prototype.Url));
            }

            if (!recordSettings.Touches && !recordSettings.FrontCamera)
            {
                StartIconVisibility = false;
            }
            if (!recordSettings.FrontCamera)
            {
                VideoIconVisibility = false;
            }
            else
            {
                await MediaCaptureInitialization();
            }
        }
        private async void CancelFunc()
        {
            if (!_ringContentVisibility)
            {
                using (var db = new PrototypingContext())
                {
                    User   user   = db.Users.Single(u => u.UserId == userId);
                    Record record = db.Records.Last();
                    db.Entry(user).Reference(u => u.Prototype).Load();
                    try
                    {
                        StorageFolder prototypeFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync(user.Prototype.Name + "_" + user.PrototypeId);

                        StorageFolder userFolder = await prototypeFolder.GetFolderAsync(user.Name + "_" + user.UserId);

                        StorageFolder recordFolder = await userFolder.GetFolderAsync("Record_" + recordSettings.RecordId);

                        await recordFolder.DeleteAsync();
                    }
                    catch (System.IO.FileNotFoundException) { }

                    db.Records.Remove(record);
                    db.SaveChanges();
                }
                Windows.UI.Xaml.Controls.Frame frame = (Windows.UI.Xaml.Controls.Frame)Windows.UI.Xaml.Window.Current.Content;
                frame.BackStack.Clear();
                frame.Navigate(typeof(DetailsUserPage), userId);
            }
        }
        private async Task <string> CreateVideoFile(int recordId)
        {
            string pathToVideo = string.Empty;

            using (var db = new PrototypingContext())
            {
                User user = db.Users.Single(u => u.UserId == userId);
                await db.Entry(user).Reference(u => u.Prototype).LoadAsync();

                string prototypeName = user.Prototype.Name + "_" + user.PrototypeId;
                string userName      = user.Name + "_" + user.UserId;
                string recordName    = "Record_" + recordId;

                StorageFolder prototypeFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync(prototypeName, CreationCollisionOption.OpenIfExists); //PrototypeName + Id

                StorageFolder userFolder = await prototypeFolder.CreateFolderAsync(userName, CreationCollisionOption.OpenIfExists);                               //UserName + Id

                StorageFolder recordFolder = await userFolder.CreateFolderAsync(recordName, CreationCollisionOption.OpenIfExists);

                videoFile = await recordFolder.CreateFileAsync("videoRecord.mp4", CreationCollisionOption.GenerateUniqueName);

                pathToVideo = videoFile.Path;
            }
            return(pathToVideo);
        }
        public async Task GetRecordScreens(Record record)
        {
            RingContentVisibility = true;
            using (var db = new PrototypingContext())
            {
                RecordModel = db.Records.Single(r => r.RecordId == record.RecordId);
                await db.Entry(RecordModel).Collection(r => r.Screens).LoadAsync();

                if (!string.IsNullOrEmpty(RecordModel.PathToVideo))
                {
                    StorageFile videoFile = await StorageFile.GetFileFromPathAsync(RecordModel.PathToVideo);

                    Windows.UI.Xaml.Controls.MediaPlayerElement player = new Windows.UI.Xaml.Controls.MediaPlayerElement();
                    player.AreTransportControlsEnabled = true;
                    player.Source       = MediaSource.CreateFromStorageFile(videoFile);
                    RecordVideo         = player;
                    VideoIconVisibility = true;
                }
                else
                {
                    VideoIconVisibility = false;
                }
                Screens = await FileToImageTransform(RecordModel.Screens);
            }
            RingContentVisibility = false;
        }
        public async Task DeleteUser(User user)
        {
            using (var db = new PrototypingContext())
            {
                User findUser = db.Users.Single(u => u.UserId == user.UserId);
                await db.Entry(findUser).Reference(u => u.Prototype).LoadAsync();

                try
                {
                    StorageFolder prototypeFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync(findUser.Prototype.Name + "_" + findUser.PrototypeId);

                    StorageFolder userFolder = await prototypeFolder.GetFolderAsync(findUser.Name + "_" + findUser.UserId);

                    await userFolder.DeleteAsync();
                }
                catch (System.IO.FileNotFoundException)
                {
                    System.Diagnostics.Debug.WriteLine("Prototype/User folder not found");
                }

                db.Users.Remove(findUser);
                db.SaveChanges();
            }
            UpdateUserList(user.PrototypeId);
        }
        private async void RemoveFunc()
        {
            using (var db = new PrototypingContext())
            {
                User user = db.Users.Single(u => u.UserId == UserModel.UserId);
                await db.Entry(user).Reference(u => u.Prototype).LoadAsync();

                try
                {
                    StorageFolder prototypeFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync(user.Prototype.Name + "_" + user.PrototypeId);

                    StorageFolder userFolder = await prototypeFolder.GetFolderAsync(user.Name + "_" + user.UserId);

                    await userFolder.DeleteAsync();
                }
                catch (System.IO.FileNotFoundException)
                {
                    System.Diagnostics.Debug.WriteLine("User folder not found");
                }

                db.Users.Remove(user);
                db.SaveChanges();
            }
            ((Windows.UI.Xaml.Controls.Frame)Windows.UI.Xaml.Window.Current.Content).Navigate(typeof(DetailsPrototypePage), UserModel.PrototypeId);
        }
        private async Task <ObservableCollection <RecordScreenModel> > HeatingScreens(List <RecordScreenModel> screens)
        {
            ObservableCollection <RecordScreenModel> result = new ObservableCollection <RecordScreenModel>();

            using (var db = new PrototypingContext())
            {
                User user = db.Users.Single(u => u.UserId == RecordModel.UserId);
                await db.Entry(user)
                .Reference(u => u.Prototype)
                .LoadAsync();

                string prototypeName = user.Prototype.Name + "_" + user.PrototypeId;
                string userName      = user.Name + "_" + user.UserId;
                string recordName    = "Record_" + RecordModel.RecordId;

                StorageFolder prototypeFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync(prototypeName, CreationCollisionOption.OpenIfExists); //PrototypeName + Id

                StorageFolder userFolder = await prototypeFolder.CreateFolderAsync(userName, CreationCollisionOption.OpenIfExists);                               //UserName + Id

                StorageFolder recordFolder = await userFolder.CreateFolderAsync(recordName, CreationCollisionOption.OpenIfExists);

                foreach (RecordScreenModel screen in screens)
                {
                    screen.HeatMapScreen = await HeatMapFunctions.CreateProcessHeatMap(screen.OriginalScreen, screen.ListPoints);

                    result.Add(screen);

                    string[] screenPaths = await SaveImagesInStorage(screen.OriginalScreen, screen.HeatMapScreen, recordFolder); //saving images in prototype -> user -> record path

                    RecordScreen rScreen = new RecordScreen()
                    {
                        RecordId             = RecordModel.RecordId,
                        Points               = screen.ListPoints,
                        UriPage              = screen.UriPage,
                        PathToOriginalScreen = screenPaths[0],
                        PathToHeatMapScreen  = screenPaths[1]
                    };
                    db.RecordScreens.Add(rScreen);
                    db.SaveChanges();
                }
            }
            return(result);
        }