private void InitHandlers()
{
Observable.FromEventPattern <ScrolledEventArgs>(
h => MainLst.Scrolled += h,
h => MainLst.Scrolled -= h)
.Select(x => x.EventArgs)
.Subscribe(async _ =>
await Task.Run(() =>
{
if (_previousY < _.ScrollY)
{
Device.BeginInvokeOnMainThread(() => CreateBtn.Hide());
}
else if (_previousY > _.ScrollY)
{
Device.BeginInvokeOnMainThread(() => CreateBtn.Show());
}
_previousY = _.ScrollY;
})
);
this.WhenAnyValue(x => x.DayPicker.SelectedDate)
.Where(x => !_action.IsNullOrEmptyOrWhiteSpace() &&
_action != TranslationCodeExtension.GetTranslation("CancelAction") &&
x.HasValue)
.Select(x => x.Value)
.Subscribe(_ =>
{
DayPicker.Date = DateTime.Today;
ViewModel.AddDayExecute(_, _action);
});
CreateBtn.Clicked = async(s, e) => await CreateDayExecute();
}
public static string DayShortName(DayOfWeek dayOfWeek)
{
switch (dayOfWeek)
{
case DayOfWeek.Monday:
return(TranslationCodeExtension.GetTranslation("MondayShortText"));
case DayOfWeek.Tuesday:
return(TranslationCodeExtension.GetTranslation("TuesdayShortText"));
case DayOfWeek.Wednesday:
return(TranslationCodeExtension.GetTranslation("WednesdayShortText"));
case DayOfWeek.Thursday:
return(TranslationCodeExtension.GetTranslation("ThursdayShortText"));
case DayOfWeek.Friday:
return(TranslationCodeExtension.GetTranslation("FridayShortText"));
case DayOfWeek.Saturday:
return(TranslationCodeExtension.GetTranslation("SaturdayShortText"));
default:
return(TranslationCodeExtension.GetTranslation("SundayShortText"));
}
}
public override void OnReceive(Context context, Intent intent)
{
using (var builder = new Notification.Builder(Application.Context))
{
builder.SetContentTitle(TranslationCodeExtension.GetTranslation("HalfWorkTitle"))
.SetContentText(TranslationCodeExtension.GetTranslation("HalfWorkText"))
.SetAutoCancel(true)
.SetSmallIcon(Resource.Drawable.icon);
var manager = (NotificationManager)Application.Context.GetSystemService(Context.NotificationService);
if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
{
var channelId = $"{Application.Context.PackageName}.general";
var channel = new NotificationChannel(channelId, "General", NotificationImportance.Default);
manager.CreateNotificationChannel(channel);
builder.SetChannelId(channelId);
}
var resultIntent = GetLauncherActivity();
resultIntent.SetFlags(ActivityFlags.NewTask | ActivityFlags.ClearTask);
var stackBuilder = Android.Support.V4.App.TaskStackBuilder.Create(Application.Context);
stackBuilder.AddNextIntent(resultIntent);
var resultPendingIntent =
stackBuilder.GetPendingIntent(0, (int)PendingIntentFlags.UpdateCurrent);
builder.SetContentIntent(resultPendingIntent);
manager.Notify(2, builder.Build());
CrossVibrate.Current.Vibration(TimeSpan.FromMilliseconds(150));
stackBuilder.Dispose();
}
}
private async Task ClearExecuteAsync()
{
IsEnable = false;
await Task.Delay(100);
var result = await Application.Current.MainPage.DisplayAlert(
TranslationCodeExtension.GetTranslation("ClearHistoryTitle"),
TranslationCodeExtension.GetTranslation("ClearHistoryText"),
TranslationCodeExtension.GetTranslation("ClearHistoryButton"),
TranslationCodeExtension.GetTranslation("NoText")
);
if (!result)
{
IsEnable = true;
return;
}
await _timeAccountingContext.Database.EnsureDeletedAsync()
.ConfigureAwait(false);
await _timeAccountingContext.Database.EnsureCreatedAsync()
.ConfigureAwait(false);
CrossToastPopUp.Current.ShowCustomToast
(
TranslationCodeExtension.GetTranslation("HistorySuccessClearText"),
"#00AB00",
"#FFFFFF"
);
await Task.Delay(50);
IsEnable = true;
}
private async Task DeleteBreakExecuteAsync(Break @break)
{
IsEnable = false;
await Task.Delay(100);
var result = await Application.Current.MainPage.DisplayAlert(
TranslationCodeExtension.GetTranslation("DeleteBreakTitle"),
TranslationCodeExtension.GetTranslation("DeleteBreakText"),
TranslationCodeExtension.GetTranslation("YesDeleteBreakText"),
TranslationCodeExtension.GetTranslation("NoText"));
if (result)
{
await Task.Delay(50);
if (!_currentAccounting.IsClosed)
{
_timeAccountingContext.Breaks.Remove(@break);
await _timeAccountingContext.SaveChangesAsync()
.ConfigureAwait(false);
}
Breaks.Remove(@break);
}
IsEnable = true;
}
public void UpdateLanguage()
{
UpdateWorkingDay();
HeaderLbl.Text = TranslationCodeExtension.GetTranslation("MainHeaderText");
CurrentBtn.Text = TranslationCodeExtension.GetTranslation("CurrentDayButton");
HistoryBtn.Text = TranslationCodeExtension.GetTranslation("HistoryButton");
SettingsBtn.Text = TranslationCodeExtension.GetTranslation("SettingsButton");
RateTlbrItm.Text = TranslationCodeExtension.GetTranslation("EstimateApp");
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var(item1, item2) = ((int, int))value;
string headerTitle;
switch (item1)
{
case 1: headerTitle = TranslationCodeExtension.GetTranslation("JanuaryText");
break;
case 2:
headerTitle = TranslationCodeExtension.GetTranslation("FebruaryText");
break;
case 3:
headerTitle = TranslationCodeExtension.GetTranslation("MarchText");
break;
case 4:
headerTitle = TranslationCodeExtension.GetTranslation("AprilText");
break;
case 5:
headerTitle = TranslationCodeExtension.GetTranslation("MayText");
break;
case 6:
headerTitle = TranslationCodeExtension.GetTranslation("JuneText");
break;
case 7:
headerTitle = TranslationCodeExtension.GetTranslation("JulyText");
break;
case 8:
headerTitle = TranslationCodeExtension.GetTranslation("AugustText");
break;
case 9:
headerTitle = TranslationCodeExtension.GetTranslation("SeptemberText");
break;
case 10:
headerTitle = TranslationCodeExtension.GetTranslation("OctoberText");
break;
case 11:
headerTitle = TranslationCodeExtension.GetTranslation("NovemberText");
break;
default:
headerTitle = TranslationCodeExtension.GetTranslation("DecemberText");
break;
}
return(headerTitle + $", {item2}");
}
private void UpdateLanguage()
{
HeaderLbl.Text = TranslationCodeExtension.GetTranslation("SettingsText");
ThemeLbl.Text = TranslationCodeExtension.GetTranslation("ThemeText");
LightThemeBtn.Text = TranslationCodeExtension.GetTranslation("LightThemeButton");
DarkThemeBtn.Text = TranslationCodeExtension.GetTranslation("DarkThemeButton");
LangLbl.Text = TranslationCodeExtension.GetTranslation("LanguageText");
WorkDaysBtn.Text = TranslationCodeExtension.GetTranslation("WeekdaysButton");
ClearBtn.Text = TranslationCodeExtension.GetTranslation("ClearHistoryButton");
SupportBtn.Text = TranslationCodeExtension.GetTranslation("SupportButton");
DevelopBtn.Text = TranslationCodeExtension.GetTranslation("DevelopTextBtn");
}
protected override bool OnBackButtonPressed()
{
if (Device.RuntimePlatform == Device.Android)
{
Device.BeginInvokeOnMainThread(async() =>
{
var result = await DisplayAlert(TranslationCodeExtension.GetTranslation("ExitTitle"),
TranslationCodeExtension.GetTranslation("ExitText"),
TranslationCodeExtension.GetTranslation("YesExitText"),
TranslationCodeExtension.GetTranslation("NoExitText"));
if (result)
{
DependencyService.Get <ICloseApp>().Close();
}
});
}
return(true);
}
protected override void OnAppearing()
{
base.OnAppearing();
this.WhenActivated(disposables =>
{
this.OneWayBind(ViewModel, vm => vm.NoElements, v => v.NoElementsLbl.IsVisible)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.NoElements, v => v.OverWorkTitleLbl.IsVisible, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.NoElements, v => v.TotalOverWorkLbl.IsVisible, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.TotalOverWork, v => v.OverWorkTitleLbl.Text, t => t >= default(TimeSpan)
? TranslationCodeExtension.GetTranslation("OverworkText") + " "
: TranslationCodeExtension.GetTranslation("WeaknessesText") + " ")
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.TotalOverWork, v => v.TotalOverWorkLbl.TextColor, t => t >= default(TimeSpan)
? Color.ForestGreen
: (Color)Application.Current.Resources["AccentColor"])
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.TotalOverWork, v => v.TotalOverWorkLbl.Text, t => t.ToString(@"dd\.hh\:mm"))
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.AllAccounts, v => v.MainLst.ItemsSource)
.DisposeWith(SubscriptionDisposables);
this.Bind(ViewModel, vm => vm.SelectedAccount, v => v.MainLst.SelectedItem)
.DisposeWith(SubscriptionDisposables);
this.WhenAnyValue(x => x.ViewModel.SelectedAccount)
.Where(x => x != null)
.Subscribe(_ => MainLst.SelectedItem = null)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.LoadingIndic.IsRunning, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.LoadingIndic.IsVisible, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.LoadingStck.IsVisible, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.MainRlt.IsEnabled)
.DisposeWith(SubscriptionDisposables);
});
}
private void PopulateFromViewModel(HistoryAccount vm)
{
DayLbl.Text = Settings.Language.IsNullOrEmptyOrWhiteSpace()
? $"{vm.TimeAccount.WorkDate:M}, {DateService.DayShortName(vm.TimeAccount.WorkDate.DayOfWeek)}"
: vm.TimeAccount.WorkDate.ToString("M", CultureInfo.GetCultureInfo(Settings.Language))
+ $", {DateService.DayShortName(vm.TimeAccount.WorkDate.DayOfWeek)}";
StartWorkSpn.Text = vm.TimeAccount.StartWorkTime.ToString(@"hh\:mm");
EndWorkSpn.Text = vm.TimeAccount.EndWorkTime.ToString(@"hh\:mm");
if (vm.TimeAccount.Breaks == null || vm.TimeAccount.Breaks.Count == 0)
{
DinnerStck.IsVisible = false;
}
else
{
var orderedBreaks = vm.TimeAccount.Breaks
.OrderBy(x => x.StartBreakTime)
.ToArray();
for (var i = 0; i < orderedBreaks.Length; i++)
{
if (i == 0)
{
DinnerLbl.Text = TimeSpan.FromMinutes(orderedBreaks[i].StartBreakTime).ToString(@"hh\:mm")
+ " - " + TimeSpan.FromMinutes(orderedBreaks[i].EndBreakTime).ToString(@"hh\:mm");
}
else
{
DinnerLbl.Text += ", " + TimeSpan.FromMinutes(orderedBreaks[i].StartBreakTime).ToString(@"hh\:mm")
+ " - " + TimeSpan.FromMinutes(orderedBreaks[i].EndBreakTime).ToString(@"hh\:mm");
}
}
BreakLbl.Text = orderedBreaks.Length > 1
? TranslationCodeExtension.GetTranslation("BreaksText")
: TranslationCodeExtension.GetTranslation("BreakText");
}
OverWorkTitle.Text = vm.DayOverWork >= 0
? TranslationCodeExtension.GetTranslation("OverworkText") + " "
: TranslationCodeExtension.GetTranslation("WeaknessesText") + " ";
OverWorkLbl.TextColor = vm.DayOverWork >= 0
? Color.ForestGreen
: (Color)Application.Current.Resources["AccentColor"];
OverWorkLbl.Text = TimeSpan.FromMinutes(vm.DayOverWork).ToString(@"hh\:mm");
}
private async Task CreateDayExecute()
{
ViewModel.IsEnable = false;
await Task.Delay(100);
_action = await Application.Current.MainPage.DisplayActionSheet(
TranslationCodeExtension.GetTranslation("SelectDayAction"),
TranslationCodeExtension.GetTranslation("CancelAction"),
null,
TranslationCodeExtension.GetTranslation("MissedDayAction"),
TranslationCodeExtension.GetTranslation("WeekendAction"),
TranslationCodeExtension.GetTranslation("WeekdayAction"));
if (!_action.IsNullOrEmptyOrWhiteSpace() &&
_action != TranslationCodeExtension.GetTranslation("CancelAction"))
{
DayPicker.Focus();
}
await Task.Delay(50);
ViewModel.IsEnable = true;
}
public void SetHalf(double minutes) => new NotificationService().Show(
TranslationCodeExtension.GetTranslation("HalfWorkTitle"),
TranslationCodeExtension.GetTranslation("HalfWorkText"),
2,
DateTime.Now.AddMinutes(minutes));
protected override void OnAppearing()
{
base.OnAppearing();
this.WhenActivated(disposables =>
{
this.BindCommand(ViewModel, vm => vm.StartWorkCommand, v => v.StartWorkBtn);
this.BindCommand(ViewModel, vm => vm.EndWorkCommand, v => v.EndWorkBtn);
this.BindCommand(ViewModel, vm => vm.AddBreakCommand, v => v.AddDinnerBtn);
this.BindCommand(ViewModel, vm => vm.SaveCommand, v => v.SaveBtn);
this.BindCommand(ViewModel, vm => vm.AllCommand, v => v.AllGstr);
this.BindCommand(ViewModel, vm => vm.CurrentCommand, v => v.CurrentGstr);
this.Bind(ViewModel, vm => vm.StartWorkTime, v => v.StartWorkTmPck.Time);
this.Bind(ViewModel, vm => vm.EndWorkTime, v => v.EndWorkTmPck.Time);
this.OneWayBind(ViewModel, vm => vm.WorkDate, v => v.DateSpn.Text, date => Settings.Language.IsNullOrEmptyOrWhiteSpace()
? $"{date:d}"
: date.ToString("d", CultureInfo.GetCultureInfo(Settings.Language)))
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.WorkDate, v => v.DaySpn.Text, date => DateService.DayShortName(date.DayOfWeek))
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.CurrentOverWork, v => v.CurrentOverWorkLbl.Text, t => t > default(TimeSpan)
? "-" + t.ToString(@"dd\.hh\:mm\:ss")
: t.ToString(@"dd\.hh\:mm\:ss"))
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.TotalOverWork, v => v.TotalOverWorkLbl.Text, t => t > default(TimeSpan)
? "-" + t.ToString(@"dd\.hh\:mm\:ss")
: t.ToString(@"dd\.hh\:mm\:ss"))
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsStarted, v => v.SaveBtn.IsVisible)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsStarted, v => v.AddDinnerBtn.IsEnabled)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsStarted, v => v.AddDinnerBtn.Opacity, v => v
? 1
: 0)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.LoadingIndic.IsRunning, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.LoadingIndic.IsVisible, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.LoadingStck.IsVisible, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.IsEnable, v => v.MainRlt.IsEnabled)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.Breaks, v => v.MainLst.ItemsSource)
.DisposeWith(SubscriptionDisposables);
this.Bind(ViewModel, vm => vm.SelectedBreak, v => v.MainLst.SelectedItem)
.DisposeWith(SubscriptionDisposables);
this.WhenAnyValue(x => x.ViewModel.SelectedBreak)
.Where(x => x != null)
.Subscribe(_ => MainLst.SelectedItem = null)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.FromHistory, v => v.SaveBtn.Text, v => v
? TranslationCodeExtension.GetTranslation("SaveDayButton")
: TranslationCodeExtension.GetTranslation("EndDayButton"))
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.FromHistory, v => v.DateTitleSpn.Text, v => !v
? TranslationCodeExtension.GetTranslation("CurrentDayText") + " "
: TranslationCodeExtension.GetTranslation("SelectedDayText") + " ")
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.FromHistory, v => v.EndStck.IsVisible)
.DisposeWith(SubscriptionDisposables);
this.OneWayBind(ViewModel, vm => vm.FromHistory, v => v.TimerGrid.IsVisible, OppositeConverter.BooleanConverterFunc)
.DisposeWith(SubscriptionDisposables);
});
ViewModel.Subscribe();
}
private static async Task AllExecuteAsync() => await Application.Current.MainPage.DisplayAlert(
TranslationCodeExtension.GetTranslation("RemainedAllTitle"),
TranslationCodeExtension.GetTranslation("RemainedAllText"),
TranslationCodeExtension.GetTranslation("OkText"));
public SettingsViewModel
(
INavigationService navigationService,
TimeAccountingContext timeAccountingContext,
Func <WorkDaysViewModel> workDaysFactory
)
{
_workDaysFactory = workDaysFactory;
_timeAccountingContext = timeAccountingContext;
_navigationService = navigationService;
ClearCommand = ReactiveCommand.CreateFromTask(ClearExecuteAsync);
WorkDaysCommand = ReactiveCommand.CreateFromTask(WorkDaysExecuteAsync);
DevelopCommand = ReactiveCommand.CreateFromTask(DevelopExecuteAsync);
LightCommand = ReactiveCommand.Create(() =>
{
if (!Settings.IsDark)
{
return;
}
Settings.IsDark = false;
ThemeService.ChangeToLight();
});
DarkCommand = ReactiveCommand.Create(() =>
{
if (Settings.IsDark)
{
return;
}
Settings.IsDark = true;
ThemeService.ChangeToDark();
});
WorkDaysCommand = ReactiveCommand.CreateFromTask(WorkDaysExecuteAsync);
InstagramCommand = ReactiveCommand.CreateFromTask(async() =>
{
InstagramBackgroundColor = Color.FromHex("#D4F4FF");
await Task.Delay(150);
await Browser.OpenAsync(new Uri(BaseValue.CreatorInstagram));
InstagramBackgroundColor = Color.Transparent;
});
VkCommand = ReactiveCommand.CreateFromTask(async() =>
{
VkBackgroundColor = Color.FromHex("#D4F4FF");
await Task.Delay(150);
await Browser.OpenAsync(new Uri(BaseValue.CreatorVk));
VkBackgroundColor = Color.Transparent;
});
GitCommand = ReactiveCommand.CreateFromTask(async() =>
{
GitBackgroundColor = Color.FromHex("#D4F4FF");
await Task.Delay(150);
await Browser.OpenAsync(new Uri(BaseValue.CreatorGithub));
GitBackgroundColor = Color.Transparent;
});
SupportCommand = ReactiveCommand.Create(() =>
{
var emailMessenger = CrossMessaging.Current.EmailMessenger;
if (emailMessenger.CanSendEmail)
{
emailMessenger.SendEmail(
BaseValue.SupportEmail,
TranslationCodeExtension.GetTranslation("MessageToSupport"),
string.Empty);
}
});
}
private async Task CurrentExecuteAsync()
{
IsEnable = false;
await Task.Delay(100);
var currentDate = DateTime.Today;
var currentAccounting = await _timeAccountingContext.TimeAccounts
.Include(x => x.Breaks)
.SingleOrDefaultAsync(x => x.WorkDate == currentDate && !x.IsClosed)
.ConfigureAwait(false);
var todayWorks = await _timeAccountingContext.TimeAccounts.Where(x => x.WorkDate == currentDate && x.IsClosed).ToArrayAsync();
var workedTime = todayWorks?.Sum(v => v.Breaks == null
? (v.EndWorkTime - v.StartWorkTime).TotalMinutes
: (v.EndWorkTime - v.StartWorkTime).TotalMinutes
- v.Breaks.Sum(d => d.EndBreakTime - d.StartBreakTime))
?? 0;
if (currentAccounting != null)
{
currentAccounting.Breaks = new ObservableCollection <Break>
(
currentAccounting.Breaks.OrderBy(y => y.StartBreakTime)
);
await _navigationService.NavigateToAsync
(
_accountFactory(currentAccounting, workedTime, false)
);
await Task.Delay(150);
IsEnable = true;
return;
}
var isWorkDay = DateService.IsWorking(currentDate.DayOfWeek);
if (!isWorkDay)
{
var result = await Application.Current.MainPage.DisplayAlert(
TranslationCodeExtension.GetTranslation("WeekendAlertTitle"),
TranslationCodeExtension.GetTranslation("WeekendAlertText"),
TranslationCodeExtension.GetTranslation("YesWeekendAlertText"),
TranslationCodeExtension.GetTranslation("NoText"));
if (!result)
{
IsEnable = true;
return;
}
await Task.Delay(50);
}
var previousAccount = await _timeAccountingContext.TimeAccounts
.Include(x => x.Breaks)
.OrderByDescending(x => x.WorkDate)
.FirstOrDefaultAsync(x => x.WorkDate < currentDate && !x.IsClosed)
.ConfigureAwait(false);
if (previousAccount != null && workedTime <= default(double))
{
if (previousAccount.IsStarted)
{
previousAccount.IsClosed = true;
previousAccount.EndWorkTime = new TimeSpan(23, 59, 59);
if (previousAccount.StartWorkTime > previousAccount.EndWorkTime)
{
previousAccount.StartWorkTime = previousAccount.EndWorkTime;
}
var workTime = previousAccount.Breaks == null
? (previousAccount.EndWorkTime - previousAccount.StartWorkTime).TotalMinutes
: (previousAccount.EndWorkTime - previousAccount.StartWorkTime).TotalMinutes
- previousAccount.Breaks.Sum(d => d.EndBreakTime - d.StartBreakTime);
previousAccount.OverWork = previousAccount.IsWorking
? workTime - DateService.WorkingTime(previousAccount.WorkDate.DayOfWeek)
: workTime;
_timeAccountingContext.Entry(previousAccount).State = EntityState.Modified;
}
else
{
_timeAccountingContext.TimeAccounts.Remove(previousAccount);
}
await _timeAccountingContext.SaveChangesAsync()
.ConfigureAwait(false);
}
var notClosedAccounts = await _timeAccountingContext.TimeAccounts
.Include(x => x.Breaks)
.Where(x => !x.IsClosed)
.ToArrayAsync()
.ConfigureAwait(false); // Can be if user change date on the device
if (notClosedAccounts.Length != 0)
{
foreach (var notClosedAccount in notClosedAccounts)
{
if (notClosedAccount.Breaks.Count != 0)
{
_timeAccountingContext.Breaks.RemoveRange(notClosedAccount.Breaks);
}
_timeAccountingContext.TimeAccounts.Remove(notClosedAccount);
}
}
currentAccounting = new TimeAccount {
WorkDate = currentDate, IsWorking = isWorkDay
};
_timeAccountingContext.TimeAccounts.Add(currentAccounting);
await _timeAccountingContext.SaveChangesAsync()
.ConfigureAwait(false);
await _navigationService.NavigateToAsync
(
_accountFactory(currentAccounting, workedTime, false)
);
await Task.Delay(150);
IsEnable = true;
}
private static async Task DevelopExecuteAsync()
{
if (!CrossConnectivity.Current.IsConnected)
{
await Application.Current.MainPage.DisplayAlert(TranslationCodeExtension.GetTranslation("ErrorConnectionTitle"),
TranslationCodeExtension.GetTranslation("ErrorConnectionText"),
TranslationCodeExtension.GetTranslation("OkText"));
return;
}
if (!CrossInAppBilling.IsSupported)
{
await Application.Current.MainPage.DisplayAlert(TranslationCodeExtension.GetTranslation("PaymentNotSupportedTitle"),
TranslationCodeExtension.GetTranslation("PaymentNotSupportedText"),
TranslationCodeExtension.GetTranslation("OkText"));
return;
}
try
{
RePurchase:
var billing = CrossInAppBilling.Current;
try
{
var connected = await billing.ConnectAsync();
if (!connected)
{
await Application.Current.MainPage.DisplayAlert(
TranslationCodeExtension.GetTranslation("StoreServicesConnectProblemTitle"),
TranslationCodeExtension.GetTranslation("StoreServicesConnectProblemText"),
TranslationCodeExtension.GetTranslation("OkText"));
return;
}
var purchase = await billing.PurchaseAsync
(
BaseValue.DevelopProductId,
ItemType.InAppPurchase,
"inAppPayLoad"
);
if (purchase != null && purchase.State == PurchaseState.Purchased)
{
await CrossInAppBilling.Current.ConsumePurchaseAsync
(
purchase.ProductId,
purchase.PurchaseToken
);
CrossToastPopUp.Current.ShowCustomToast
(
TranslationCodeExtension.GetTranslation("DevelopThanksText"),
"#00AB00",
"#FFFFFF"
);
}
}
catch (InAppBillingPurchaseException purchaseEx)
{
switch (purchaseEx.PurchaseError)
{
case PurchaseError.AlreadyOwned:
await CrossInAppBilling.Current.ConsumePurchaseAsync
(
BaseValue.DevelopProductId,
ItemType.InAppPurchase,
"inAppPayLoad"
);
await billing.DisconnectAsync();
goto RePurchase;
case PurchaseError.UserCancelled: break;
default:
await Application.Current.MainPage.DisplayAlert
(
TranslationCodeExtension.GetTranslation("StoreServicesUnavailableTitle"),
TranslationCodeExtension.GetTranslation("StoreServicesUnavailableText"),
TranslationCodeExtension.GetTranslation("OkText")
);
break;
}
}
finally
{
await billing.DisconnectAsync();
}
}
catch
{
await Application.Current.MainPage.DisplayAlert
(
TranslationCodeExtension.GetTranslation("StoreServicesUnavailableTitle"),
TranslationCodeExtension.GetTranslation("StoreServicesUnavailableText"),
TranslationCodeExtension.GetTranslation("OkText")
);
}
}
public static string IsWorkDay(DayOfWeek dayOfWeek) => DayShortName(dayOfWeek)
+ (IsWorking(dayOfWeek)
? ", " + TranslationCodeExtension.GetTranslation("WeekdayText")
: ", " + TranslationCodeExtension.GetTranslation("WeekendText"));
public void SetEnd(double minutes) => new NotificationService().Show(
TranslationCodeExtension.GetTranslation("DayIsOverTitle"),
TranslationCodeExtension.GetTranslation("DayIsOverText"),
1,
DateTime.Now.AddMinutes(minutes));
