public async Task Delete()
        {
            TTRepository repository = new TTRepository();

            await repository.DeleteAsync(this.Check);

            this.Hours.Remove(this);
        }
        public static async Task<ObservableCollection<Month>> Get()
        {
            if (historic != null)
                return historic;

            PersonalInfoRespository repository = new PersonalInfoRespository();

            PersonalInfo personalInfo = await repository.LoadAsync();

            var ttRepository = new TTRepository();

            var storedHistoricalChecks = await ttRepository.FindAllByUserNameAsync(personalInfo.login);

            int daysToCheck;
            if (DateTime.Now.Day > 20)
            {  // do dia 21 ao 20 do próximo mês
                daysToCheck = DateTime.Now.Day - 20;

            }
            else
            { // do dia 21 do mês passado ao dia 20 do mês atual
                var day20 = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 20).AddMonths(-1);
                daysToCheck = (int)DateTime.Now.Subtract(day20).TotalDays;
            }

            var historicalChecks = new List<TTCheck>(storedHistoricalChecks);

            // Add empty checks to days without checks
            for (var i = 0; i < daysToCheck; i++)
            {
                var day = DateTime.Now.AddDays(-i);
                if (!day.IsWeekend() && !HasCheckInDay(storedHistoricalChecks, day))
                {
                    historicalChecks.Add(new TTCheck() { DateTime = day, UserName = String.Empty });
                }
            }

            historic = getMonths(historicalChecks);

            return historic;
        }
        public async Task <DateTime?> CheckInOrOutAsync()
        {
            var client = new TTClient();

#if DEBUG
            var checkinDatetime = await this.doCheckInOrOutMockAsync();
#else
            var checkinDatetime = await client.DoCheckInOrOutAsync(SecurityService.getCredential().Item1, SecurityService.getCredential().Item2);
#endif

            if (checkinDatetime.HasValue)
            {
                var repository = new TTRepository();
                var check      = new TTCheck();
                check.UserName = SecurityService.getCredential().Item1;
                check.DateTime = checkinDatetime.Value;
                await Historic.Historic.AddAsync(check);
            }

            return(checkinDatetime);
        }
        public async Task<DateTime?> CheckInOrOutAsync()
        {
            var client = new TTClient();
                        
#if DEBUG
            var checkinDatetime = await this.doCheckInOrOutMockAsync();
#else
            var checkinDatetime = await client.DoCheckInOrOutAsync(SecurityService.getCredential().Item1, SecurityService.getCredential().Item2);
#endif

            if (checkinDatetime.HasValue)
            {
                var repository = new TTRepository();
                var check = new TTCheck();
                check.UserName = SecurityService.getCredential().Item1;
                check.DateTime = checkinDatetime.Value;
                await Historic.Historic.AddAsync(check);
            }

            return checkinDatetime;
        }
        public static async Task AddAsync(TTCheck check)
        {
            TTRepository repository = new TTRepository();

            await repository.SaveAsync(check);

            Month month = historic.SingleOrDefault(
                m => m.Check.DateTime.Month == check.DateTime.Month && m.Check.DateTime.Year == check.DateTime.Year);

            if (month != null)
            {
                Day day = month.Days.SingleOrDefault(d => d.Check.DateTime.Day == check.DateTime.Day);

                if (day != null)
                {
                    Hour hour = day.Hours.FirstOrDefault(h => h.Check.DateTime.Ticks < check.DateTime.Ticks);

                    int i = day.Hours.Count;

                    if (hour != null)
                        i = day.Hours.IndexOf(hour);                                       

                    day.Hours.Insert(i, new Hour(day.Hours)
                    {
                        Check = check
                    });
                }
                else
                    month.Days.Insert(0, new Day
                    {
                        Hours = getHours(new TTCheck[] { check }),
                        Check = check
                    });

            }
            else
                historic.Insert(0, new Month
                {
                    Check = check,
                    Days = new ObservableCollection<Day>(getDays(new TTCheck[] { check }))
                });
        }