public EmployeeControlHomeViewModel()
        {
            LoadingManager  = new LoadingManager();
            Username        = App.LogUser.Name;
            StorePresenters = new ObservableCollection <StorePresenters>();

            Task.Run(async() =>
            {
                LoadingManager.OnLoading();
                await GetUserEmployeeInformation();

                LoadingManager.OffLoading();
            });

            SignOutCommand = new Command(async() =>
            {
                await App.ComunicationService.Disconnect();


                if (App.UsersConnected != null)
                {
                    App.UsersConnected.IsDisable = true;
                    var result = await userConnectedDataStore.UpdateItemAsync(App.UsersConnected);

                    if (result)
                    {
                        App.UsersConnected = null;
                    }
                }
                await Shell.Current.GoToAsync("../LoginRoute");
            });
        }
        async Task LoadOrders(string value)
        {
            LoadingManager.OnLoading();
            Status _statusvalue = (Status)Enum.Parse(typeof(Status), value);

            var orderData = await orderDataStore.GetOrdersOfUserWithSpecificStatus(App.LogUser.UserId, _statusvalue, App.TokenDto.Token);


            KeyValues.Clear();

            KeyValues.Add("orderAdded", orderData);

            UserOrders.Clear();

            foreach (var item in orderData)
            {
                item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());

                var presenter = new OrderPresenter(item);

                UserOrders.Add(presenter);
            }

            LoadingManager.OffLoading();
        }
        public async Task LoadItems()
        {
            LoadingManager.OnLoading();

            TokenExpManger tokenExpManger = new TokenExpManger(App.TokenDto.Exp);

            if (tokenExpManger.IsExpired())
            {
                await tokenExpManger.CloseSession();

                LoadingManager.OffLoading();
            }
            else
            {
                var storeData = await StoreDataStore.GetAvailableStore();

                if (!KeyValues.ContainsKey("storeAdded"))
                {
                    KeyValues.Add("storeAdded", storeData);
                }

                if (Stores.Count > 0)
                {
                    Stores.Clear();
                }

                foreach (var store in storeData)
                {
                    var storepresenter = new StorePresenters(store);

                    Stores.Add(storepresenter);
                }

                LoadingManager.OffLoading();
            }
        }
        public async Task LoadDifferentItems()
        {
            LoadingManager.OnLoading();

            TokenExpManger tokenExpManger = new TokenExpManger(App.TokenDto.Exp);

            if (tokenExpManger.IsExpired())
            {
                await tokenExpManger.CloseSession();

                LoadingManager.OffLoading();
            }
            else
            {
                if (!KeyValues.ContainsKey("storeAdded"))
                {
                    await LoadItems();
                }
                else
                {
                    var storeData = await StoreDataStore.GetDifferentStore(KeyValues["storeAdded"]);

                    if (storeData != null)
                    {
                        var tempData = new List <Store>();


                        foreach (var item in KeyValues["storeAdded"])
                        {
                            if (!tempData.Any(s => s.StoreId == item.StoreId))
                            {
                                tempData.Add(item);
                            }
                        }

                        foreach (var item in storeData)
                        {
                            if (!tempData.Any(s => s.StoreId == item.StoreId))
                            {
                                tempData.Add(item);
                            }
                        }


                        KeyValues.Clear();
                        KeyValues.Add("storeAdded", tempData);

                        foreach (var item in KeyValues["storeAdded"])
                        {
                            if (!Stores.Any(s => s.StoreId == item.StoreId))
                            {
                                var storepresenter = new StorePresenters(item);


                                Stores.Add(storepresenter);
                            }
                        }
                    }
                }



                LoadingManager.OffLoading();
            }
        }
        async Task LoadUserOrderWithStatus(string value)
        {
            LoadingManager.OnLoading();
            Status _statusvalue = (Status)Enum.Parse(typeof(Status), value);

            var orderData = await orderDataStore.GetOrdersOfUserWithSpecificStatus(App.LogUser.UserId, _statusvalue, App.TokenDto.Token);

            if (!KeyValues.ContainsKey("orderAdded"))
            {
                KeyValues.Add("orderAdded", orderData);
            }


            switch (_statusvalue)
            {
            case Status.Completed:
            {
                List <Order> tempData = new List <Order>();

                var data = await orderDataStore.GetOrdersOfUserWithSpecificStatusDifferent(KeyValues["orderAdded"], _statusvalue, App.LogUser.UserId);

                if (data != null)
                {
                    foreach (var item in KeyValues["orderAdded"])
                    {
                        if (!tempData.Any(o => o.OrderId == item.OrderId))
                        {
                            tempData.Add(item);
                        }
                    }

                    foreach (var item in data)
                    {
                        if (!tempData.Any(s => s.StoreId == item.StoreId))
                        {
                            tempData.Add(item);
                        }
                    }

                    KeyValues.Clear();
                    KeyValues.Add("orderAdded", tempData);


                    foreach (var item in KeyValues["orderAdded"])
                    {
                        if (!UserOrders.Any(s => s.OrderId == item.OrderId))
                        {
                            //Task.Run(async() =>
                            //{
                            //    item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());

                            //}).Wait();

                            item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());

                            var presenter = new OrderPresenter(item);

                            UserOrders.Add(presenter);
                        }
                    }
                }



                break;
            }

            case Status.NotSubmited:
            {
                List <Order> tempData = new List <Order>();

                var data = await orderDataStore.GetOrdersOfUserWithSpecificStatusDifferent(KeyValues["orderAdded"], _statusvalue, App.LogUser.UserId);

                if (data != null)
                {
                    foreach (var item in KeyValues["orderAdded"])
                    {
                        if (!tempData.Any(o => o.OrderId == item.OrderId))
                        {
                            tempData.Add(item);
                        }
                    }

                    foreach (var item in data)
                    {
                        if (!tempData.Any(s => s.StoreId == item.StoreId))
                        {
                            tempData.Add(item);
                        }
                    }

                    KeyValues.Clear();
                    KeyValues.Add("orderAdded", tempData);


                    foreach (var item in KeyValues["orderAdded"])
                    {
                        if (!UserOrders.Any(s => s.OrderId == item.OrderId))
                        {
                            item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());

                            var presenter = new OrderPresenter(item);

                            UserOrders.Add(presenter);
                        }
                    }
                }

                break;

                //UserOrders.Clear();

                //foreach (var item in orderData)
                //{

                //    item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
                //    var presenter = new OrderPresenter(item);

                //    UserOrders.Add(presenter);
                //}
            }

            case Status.Submited:
            {
                List <Order> tempData = new List <Order>();

                var data = await orderDataStore.GetOrdersOfUserWithSpecificStatusDifferent(KeyValues["orderAdded"], _statusvalue, App.LogUser.UserId);

                if (data != null)
                {
                    foreach (var item in KeyValues["orderAdded"])
                    {
                        if (!tempData.Any(o => o.OrderId == item.OrderId))
                        {
                            tempData.Add(item);
                        }
                    }

                    foreach (var item in data)
                    {
                        if (!tempData.Any(s => s.StoreId == item.StoreId))
                        {
                            tempData.Add(item);
                        }
                    }

                    KeyValues.Clear();
                    KeyValues.Add("orderAdded", tempData);


                    foreach (var item in KeyValues["orderAdded"])
                    {
                        if (!UserOrders.Any(s => s.OrderId == item.OrderId))
                        {
                            item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());

                            var presenter = new OrderPresenter(item);

                            UserOrders.Add(presenter);
                        }
                    }
                }


                //UserOrders.Clear();

                //foreach (var item in orderData)
                //{

                //    item.StoreOrder = await StoreDataStore.GetItemAsync(item.StoreId.ToString());
                //    var presenter = new OrderPresenter(item);

                //    UserOrders.Add(presenter);
                //}

                break;
            }

            default:
                break;
            }

            LoadingManager.OffLoading();
        }