/// <summary>
        /// Metoda pobiera z WebServisu informacje o użytkowniku, którego nie ma w Usłudze.
        /// </summary>
        /// <param name="guest">Parametr z którego pobierane są informacje, którego użytkownika dodać.</param>
        private async Task AddNewUser(SimpleBookingUser guest)
        {
            Logs.WriteErrorLog("AddNewUser");
            Logs.WriteErrorLog("guest.UserId: " + guest.UserId.ToString() + ", Booking title: " + guest.BookingTitle);

            GetUserInfoResponse userInfo = null;

            userInfo = await WebServiceConnection.SendGet <GetUserInfoResponse>("user/" + guest.UserId + "/info");

            if (userInfo == null)
            {
                Logs.WriteErrorLog("UserInfo zwrocilo null z WebSerwisu");
            }
            if (userInfo.Email == null)
            {
                Logs.WriteErrorLog("UserEmil zwrocil null");
            }
            var userNew = new User(userInfo.Email, guest.UserId);

            //userNew.UserId = guest.UserId;
            Logs.WriteErrorLog("UserNew.UserEmail: " + userNew.UserEmail + ", UserNew.UserId" + userNew.UserId);
            //Autoryzuj użytkownika, zakładając że jego token istnieje.
            userNew.Calendar.AuthorizeTask();
            if (userNew.Calendar.IsCalendarAuthorized == false)
            {
                return;
            }
            Logs.WriteErrorLog("uzytkownik " + userNew.UserEmail + " zostal zautoryzowany.");
            userNew.Calendar.Service.Events.QuickAdd("primary", "Testujemy poprawnosc autoryzacji").ExecuteAsync();

            _usersList.Add(userNew);
            Logs.WriteErrorLog("Pierwszy uzytkownik w kolejce to: " + _usersList.First().UserEmail);
        }
        /// <summary>
        /// Metoda wysyła zapytanie do Webservice'u o token wybranego użytkownika.
        /// </summary>
        /// <param name="userId">Numer id użytkownika (w bazie danych), którego token ma być zwrócony.</param>
        /// <returns>Zwraca string jako wynik zadania. Jest to wartość tokenu do odświeżenia autoryzacji użytkownika lub w przypadku niepowodzenia, wartość null .</returns>
        public static async Task <string> GetTokenFromDatabase(int userId)
        {
            Logs.WriteErrorLog("GetTokenFromDatabase.");
            var tokenRequest = new GetGoogleTokenRequest()
            {
                Id       = userId,
                SenderId = LoginToWebServiceData.WebServiceId,
                Token    = LoginToWebServiceData.WebServiceToken
            };

            Logs.WriteErrorLog("User id: " + tokenRequest.Id.ToString() + ", ServiceID" + tokenRequest.SenderId.ToString() + ", Token: " + tokenRequest.Token.ToString());
            var tokenResponse = await WebServiceConnection.
                                SendPost <GetGoogleTokenRequest, GetGoogleTokenResponse>(tokenRequest, "google/token/show");

            if (tokenResponse == null)
            {
                Logs.WriteErrorLog("Brak odpowiedzi o tokenie od WebService'u.");
                return(null);
            }
            Logs.WriteErrorLog("Status: " + tokenResponse.Status.ToString() + ", Message: " + tokenResponse.Message + ", GoogleToken: " + tokenResponse.GoogleToken);
            if (tokenResponse.Status == 2)
            {
                return(null);
            }
            Logs.WriteErrorLog("GetTokenFromWebService: " + tokenResponse.GoogleToken.ToString());
            return(tokenResponse.Status == 0 ? tokenResponse.GoogleToken : null);
        }
        /// <summary>
        /// Medota odpowiedzialna za odświeżenie tokenu co godzinę.
        /// </summary>
        /// <returns>Zwraca nowy token w formie stringa.</returns>
        public static string RefreshToken()
        {
            var updateTokenRequest = new UpdateTokenRequest();
            UpdateTokenResponse updateTokenResponse =
                WebServiceConnection.SendPost <UpdateTokenRequest, UpdateTokenResponse>(updateTokenRequest,
                                                                                        "token/update").Result;

            Logs.WriteErrorLog("Nowy token: " + updateTokenResponse.Token);
            WriteLastTokenToFile(updateTokenResponse.Token);
            return(updateTokenResponse.Token ?? null);
        }
        /// <summary>
        /// Metoda logowania do WebServisu wywoływana na starcie
        /// </summary>
        private async Task LoginToWebService()
        {
            var time         = DateTime.Today.ToShortDateString();
            var tokenRequest = new UpdateTokenRequest()
            {
                SenderId = LoginToWebServiceData.WebServiceId,
                // Token = time
                Token = "6z6d3YD4UT7faV3nZk6kp4hOG1KDsaNLTDyfRK3NZim2JR39caRiwGDbsrGcn9MTgwvHxYFprsugRpeZ7KBrtEon9wWzd0z0GCWn"
                        // Token = LoginToWebServiceData.ReadLastWebServiceToken()
            };
            var tokenResponse = await WebServiceConnection.SendPost <UpdateTokenRequest, UpdateTokenResponse>(tokenRequest, "token/update");

            LoginToWebServiceData.WebServiceToken = tokenResponse.Token;
            if (tokenResponse != null)
            {
                if (tokenResponse.Status == 0)
                {
                    Logs.WriteErrorLog("Zalogowano do WS z " + tokenResponse.Token);
                    LoginToWebServiceData.WriteLastTokenToFile(tokenResponse.Token);
                }
                Logs.WriteErrorLog(tokenResponse.Status.ToString());
            }
        }
        /// <summary>
        /// Metoda wywołująca żądanie przeniesienia odbytych spotkań do archiwum.
        /// Wydarzenia przenoszone są do archiwum po 3 miesiącach od daty zakończenia.
        /// </summary>
        private async void SendToArchive()
        {
            var sendToArchiveRequest = new SendToArchiveRequest()
            {
                Months   = 6,
                SenderId = LoginToWebServiceData.WebServiceId,
                Token    = LoginToWebServiceData.WebServiceToken
            };

            var sendToArchiveResponse = await WebServiceConnection.
                                        SendPost <SendToArchiveRequest, SendToArchiveResponse>(sendToArchiveRequest, "send/to/archive");

            if (sendToArchiveResponse == null)
            {
                return;
            }
            if (sendToArchiveResponse.Status == 0)
            {
                Logs.WriteErrorLog("Wydarzenia z przed " + sendToArchiveRequest.Months + " miesiecy, zostały zarchiwizowane");
                return;
            }
            Logs.WriteErrorLog("Archiwizacja nie powiodla sie.");
        }
        /// <summary>
        /// Metoda odpytująca WebService o nowe zdarzenia w przedziale czasowym określonym w jako argumenty metody.
        /// </summary>
        /// <param name="timeBefore">Początek przedziału czasowego.</param>
        /// <param name="timeNow">Koniec przedziału czasowego.</param>
        /// <returns></returns>
        private async void AskAboutNewEventsTask(DateTime timeBefore, DateTime timeNow)
        {
            // Obiekt metody WebServisu pozwalająca zainicjalizować żądanie pobrania rezerwacji WYKONANYMI między określonym czasem.
            _bookingsRequest = new GetBookingsCreatedBetweenDatesRequest()
            {
                BeginTime = timeBefore,
                EndTime   = timeNow,
                SenderId  = LoginToWebServiceData.WebServiceId,
                Token     = LoginToWebServiceData.WebServiceToken
            };

            // Obiekt metody WebServisu przyjmujący odpowiedź na zapytanie o rezerwację sal,
            // wykonane w podanym przedziale czasowym.
            var bookingsResponse = await WebServiceConnection.
                                   SendPost <GetBookingsCreatedBetweenDatesRequest, GetBookingsCreatedBetweenDatesResponse>(_bookingsRequest, "booking/dates");

            if (bookingsResponse != null)
            {
                if (bookingsResponse.Status == 0)
                {
                    foreach (var booking in bookingsResponse.BookingsList)
                    {
                        Logs.WriteErrorLog("Ilosc rezerwacji w booking: " + booking.GuestList.Count.ToString());
                        foreach (var guest in booking.GuestList)
                        {
                            var userInfo =
                                await WebServiceConnection.SendGet <GetUserInfoResponse>("user/" + guest.UserId + "/info");

                            if (userInfo == null)
                            {
                                Logs.WriteErrorLog("Nie odzyskalem odpowiedzi od WS");
                            }
                            if (userInfo.Email.EndsWith("@gmail.com") == false)
                            {
                                continue;
                            }
                            Logs.WriteErrorLog("guest.BookingTitle: " + guest.BookingTitle);
                            Logs.WriteErrorLog("guest.userId: " + guest.UserId.ToString());

                            var userItem = _usersList.FirstOrDefault(u => u.UserId == guest.UserId);

                            if (userItem == null)
                            {
                                Logs.WriteErrorLog("Uzytkownika nie ma w kolejce, ani na liscie. Dodaje go...");
                                await AddNewUser(guest);
                            }
                            Logs.WriteErrorLog("Dodalem uzytkownika, tutaj sie zacinam.");
                            userItem = _usersList.FirstOrDefault(u => u.UserId == guest.UserId);
                            AddNewEvent(guest, userItem);
                            await UpdateAllCalendars();
                        }
                        //Dodaj Kalendarz i wywołaj metodę booking dla kalendarza użytkownika.
                        //booking.GuestList[0].Confirmation
                        //Logs.WriteErrorLog(booking.Title + ": " + booking.Description);
                    }
                    await UpdateAllCalendars();
                }
                else
                {
                    Logs.WriteErrorLog(bookingsResponse.Status + ": " + bookingsResponse.Message);
                }
            }
            else
            {
                Logs.WriteErrorLog("Nie udalo sie otrzymac odpowiedzi od WebService'u");
            }
        }