public SingleReportPurchaseViewModel(ValidationModel validation, Action <Uri> openUri, string runtimePlatform, AlertUtility alertUtility, MainThreadNavigator nav, IToastService toastService, IPurchasedReportService prService, IPurchasingService purchaseService, ICurrentUserService userCache, ICache <PurchasedReportModel> prCache, ILogger <SingleReportPurchaseViewModel> emailLogger) { _validation = validation; _openUri = openUri; _nav = nav; _toastService = toastService; _runtimePlatform = runtimePlatform; _userCache = userCache; _purchaseService = purchaseService; _prService = prService; _prCache = prCache; _emailLogger = emailLogger; _alertUtility = alertUtility; SetViewState(validation); }
private void HandleUpdatesForStopStartProgram(ProgressResponse response, ProgramViewModel program, bool start) { MainThreadUtility.InvokeOnMain(() => { if (response != null) { DataCache.AddCommandProgress(new CommandProgress(CommandType.StartPrograms, response.Body, new string[] { program.Id })); if (response.IsFinal) { Action resetProgram = () => { program.Starting = false; //ServiceContainer.DeviceService.RequestDevice(this.Device.Device); }; if (response.IsSuccessful) { //AlertUtility.ShowProgressResponse("Stop/Start Program " + program.Id, response); this.RegisterForAsyncUpdate(resetProgram, 5000); } else { this.RegisterForAsyncUpdate(resetProgram); if ((bool)!response?.IsReconnectResponse && (bool)!response?.IsServerDownResponse) { AlertUtility.ShowAppError(response?.ErrorBody); } } } } }); }
//edited private void SetDismissAllButton() { ExceptionUtility.Try(() => { if (this.HasAccessLevelToDelete()) { if (this.NavigationItem != null) { this.NavigationItem.RightBarButtonItem = new UIBarButtonItem(StringLiterals.DismissAll, UIBarButtonItemStyle.Plain, (o, e) => { if (this.NavigationController != null) { // this.NavigationController.PopViewController(false); ExceptionUtility.Try(() => { string title = StringLiterals.Alert; AlertUtility.ShowConfirmationAlert(title, StringLiterals.DismissAllAlertsConfirmationMessage(), (b) => { if (b) { DismissAlertsConfirmed(); } }, StringLiterals.YesButtonText); }); } }); } } }); }
public PurchaseViewModel(IToastService toastService, IPurchasingService purchaseService, ICache <SubscriptionModel> subCache, ISubscriptionService subService, ICurrentUserService userCache, MainThreadNavigator nav, ValidationModel validationModel, string runtimePlatform, Action <BaseNavPageType> navigateFromMenu, AlertUtility alertUtility, Action <Uri> openUri) { _toastService = toastService; _purchaseService = purchaseService; _subCache = subCache; _subService = subService; _userCache = userCache; _validationModel = validationModel; _runtimePlatform = runtimePlatform; _openUri = openUri; _alertUtility = alertUtility; _nav = nav; _navigateFromMenu = navigateFromMenu; LegalLinkCommand = new Command(() => _openUri(new Uri(Configuration.PrivacyPolicyUrl))); PurchaseButtonCommand = new Command(() => PurchaseButtonClicked()); SetVisualState(validationModel); }
private void HandleUpdatesForPrev(ProgressResponse response) { MainThreadUtility.InvokeOnMain(() => { if (response != null) { DataCache.AddCommandProgress(new CommandProgress(CommandType.DevicePrev, response.Body)); if (response.IsFinal) { this.Device.Preving = false; this.SetButtonMode(this._prevButton, this._prevButtonSpinner, false); if (response.IsSuccessful) { } else { if ((bool)!response?.IsReconnectResponse && (bool)!response?.IsServerDownResponse) { AlertUtility.ShowAppError(response?.ErrorBody); } } } } AlertUtility.ShowProgressResponse(this._prevFeature.ProgressText, response); }); }
private void NavigateToDeviceDetails(DeviceViewModel device) { try { ProgressUtility.SafeShow("Getting Device Details", async() => { var response = await ServiceContainer.DeviceService.RequestDevice(device.Device, () => { NavigateToDeviceDetails(device); }); MainThreadUtility.InvokeOnMain(() => { if (response != null && response.IsSuccessful) { var d = response.Body.Devices.Items.FirstOrDefault().Value; if (d == null) { ProgressUtility.Dismiss(); AlertUtility.ShowErrorAlert(StringLiterals.Error, StringLiterals.DeviceNotFoundErrorTitle); } else { this.Predecessor = null; ProgressUtility.Dismiss(); this.NavigateTo(DeviceDetailsViewController.CreateInstance(d.Id)); } } }); }); } catch (Exception e) { LogUtility.LogException(e); } }
protected override void HandleViewDidAppear(bool animated) { base.HandleViewDidAppear(animated); if (this.ShowConnectionError) { this.ShowConnectionError = false; AlertUtility.ShowErrorAlert(StringLiterals.ConnectionError, StringLiterals.AuthFailureMessage); Aquamonix.Mobile.IOS.Utilities.WebSockets.ConnectionManager.ReconnectProcess.Begin(showBannerStraightAway: true); } }
public OrderViewModel(IOrderValidationService validator, ICurrentUserService userCache, IOrderService orderService, IToastService toast, IPageFactory pageFactory, MainThreadNavigator nav, IMessagingSubscriber topicSubscriber, ILogger <OrderViewModel> logger, string deviceType, AlertUtility alertUtility, Action <BaseNavPageType> baseNavigationAction, ICache <Models.Order> orderCache) { _orderValidator = validator; _userService = userCache; _toast = toast; _nav = nav; _orderService = orderService; _pageFactory = pageFactory; _orderCache = orderCache; _alertUtility = alertUtility; _topicSubscriber = topicSubscriber; _baseNavigationAction = baseNavigationAction; _deviceType = deviceType; _logger = logger; PurchaseOptionsCommand = new Command(async() => { var val = await _orderValidator.ValidateOrderRequest(_userService.GetLoggedInAccount()); if (SubscriptionUtility.SubscriptionActive(val.Subscription)) { _nav.Push(_pageFactory.GetPage(PageType.SingleReportPurchase, val)); } else { _nav.Push(_pageFactory.GetPage(PageType.PurchaseOptions, val)); } }); OptionsInfoCommand = new Command(async() => await alertUtility.Display("Roof Option Selection", $"Selecting a roof option allows Fair Squares to determine what roofs you would like measured at the submitted address.{Environment.NewLine}" + $"{Environment.NewLine}Primary Only- Fair Squares will measure the primary structure, including attached garage.{Environment.NewLine}" + $"Detached Garage- Fair Squares will also measure the detached garage on the property.{Environment.NewLine}" + $"Shed/Barn- Fair Squares will also measure a shed or barn on the property.{Environment.NewLine}" + $"{Environment.NewLine}NOTE: Fair Squares only supports measuring one primary structure per report (with a detached garage or shed/barn if needed).", "Ok")); ErrorMessageRowHeight = 0; SelectedOptionIndex = -1; SelectedStateIndex = -1; #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed SetVisualStateForValidation(); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed }
private void HandleUpdatesForTestStations(ProgressResponse response, string[] stationIds) { MainThreadUtility.InvokeOnMain(() => { if (response != null) { DataCache.AddCommandProgress(new CommandProgress(CommandType.TestStations, response.Body, stationIds)); if (response.IsFinal) { Action resetStations = () => { foreach (string id in stationIds) { var station = this.Device?.Device?.Stations.Values.Where((d) => d.Id == id).FirstOrDefault(); if (station != null) { station.Selected = false; station.Starting = false; } } }; if (response.IsSuccessful) { //AlertUtility.ShowAlert("Testing Stations", "Testing Stations"); this.RegisterForAsyncUpdate(resetStations, 5000); } else { this.RegisterForAsyncUpdate(resetStations); if ((bool)!response?.IsReconnectResponse && (bool)!response?.IsServerDownResponse) { AlertUtility.ShowAppError(response?.ErrorBody); } } DataCache.TriggerDeviceUpdate(this.DeviceId); int countSelected = Device.Stations.Where((s) => s.Selected).Count(); this._buttonFooterView.PermaDisabled = false; this.ShowHideButtonFooter(countSelected); this._selectionHeaderView.Enabled = true; /* * this.LoadData(); */ } } }); }
private void HandleUpdatesForStartCircuits(ProgressResponse response, string[] circuitIds, int durationMinutes) { MainThreadUtility.InvokeOnMain(() => { if (response != null) { DataCache.AddCommandProgress(new CommandProgress(CommandType.StartCircuits, response.Body, circuitIds)); if (response.IsFinal) { Action resetCircuits = () => { foreach (string id in circuitIds) { var circuit = this.Device?.Device?.Circuits.Values.Where((d) => d.Id == id).FirstOrDefault(); if (circuit != null) { circuit.Selected = false; circuit.Starting = false; } } }; if (response.IsSuccessful) { //AlertUtility.ShowAlert("Start Circuits", "Start Circuits"); this.RegisterForAsyncUpdate(resetCircuits, 5000); } else { this.RegisterForAsyncUpdate(resetCircuits); if ((bool)!response?.IsReconnectResponse && (bool)!response?.IsServerDownResponse) { AlertUtility.ShowAppError(response?.ErrorBody); } } DataCache.TriggerDeviceUpdate(this.DeviceId); int countSelected = Device.Circuits.Where((s) => s.Selected).Count(); this._buttonFooterView.PermaDisabled = false; this.ShowHideButtonFooter(countSelected > 0); this._selectionHeaderView.Enabled = true; } } AlertUtility.ShowProgressResponse("Start Circuits", response); }); }
public FeedbackViewModel(INotificationService notifier, ICurrentUserService userCache, AlertUtility alertUtility, IPageFactory pageFactory, ILogger <FeedbackViewModel> logger, MainThreadNavigator nav) { _notifier = notifier; _pageFactory = pageFactory; _userCache = userCache; _nav = nav; _logger = logger; _alertUtility = alertUtility; SubmitCommand = new Command(async() => await SubmitFeedback(_feedbackEntry)); }
private void WaterSelectedStations(IEnumerable <PumpViewModel> pumps, int durationMinutes) { ExceptionUtility.Try(() => { IEnumerable <string> stationNames, stationNumbers; this.GetSelectedStationsList(out stationNames, out stationNumbers); AlertUtility.ShowConfirmationAlert(StringLiterals.StartStationConfirmationTitle, StringLiterals.FormatStartStationConfirmationMessage(stationNames, stationNumbers), (b) => { if (b) { this.WaterSelectedStationsConfirmed(pumps, durationMinutes); } }, okButtonText: StringLiterals.StartButtonText); }); }
private void ShowEmail() { ExceptionUtility.Try(() => { #if DEBUG string recipients = "*****@*****.**"; #else string recipients = AppSettings.GetAppSettingValue <string>(AppSettings.LogEmailRecipientsAppSettingName, "*****@*****.**"); #endif if (MFMailComposeViewController.CanSendMail) { LogUtility.LogMessage("Preparing to send diagnostic email to " + recipients, LogSeverity.Info); MFMailComposeViewController mailVc = new MFMailComposeViewController(); mailVc.SetToRecipients(new string[] { recipients }); string subject = StringLiterals.SupportRequestSubject; //if (User.Current != null) // subject += " " + User.Current.Username; mailVc.SetSubject(subject); string message = StringLiterals.EmailText + this.GetDeviceInfoAsString(); mailVc.SetMessageBody(message, false); mailVc.Finished += (object s, MFComposeResultEventArgs args) => { LogUtility.LogMessage("Diagnostic email sent to " + recipients, LogSeverity.Info); System.Diagnostics.Debug.WriteLine(args.Result.ToString()); args.Controller.DismissViewController(true, null); }; string logData = LogUtility.GetLogData(); mailVc.AddAttachmentData(NSData.FromString(logData), "text/plain", "logfile.txt"); this.NavigationController.PresentViewController(mailVc, true, () => { }); } else { AlertUtility.ShowAlert( StringLiterals.NoMailSupportAlertTitle, String.Format(StringLiterals.NoMailSupportAlertMessage, recipients) ); } }); }
private void TestSelectedStations() { ExceptionUtility.Try(() => { IEnumerable <string> stationNames, stationNumbers; this.GetSelectedStationsList(out stationNames, out stationNumbers); //var selectedStationIds = this.Device.Stations.Where((s) => s.Selected).Select((s) => s.Id); AlertUtility.ShowConfirmationAlert(StringLiterals.TestStationConfirmationTitle, StringLiterals.FormatTestStationConfirmationMessage(stationNames, stationNumbers), (b) => { if (b) { this.TestSelectedStationsConfirmed(); } }, okButtonText: StringLiterals.TestButtonText); }); }
private void PrevButtonClicked() { ExceptionUtility.Try(() => { LogUtility.LogMessage("User clicked PREV button (footer)."); string deviceId = this.Device?.Id; if (!String.IsNullOrEmpty(deviceId)) { AlertUtility.ShowConfirmationAlert(this._prevFeature.ProgressText, _prevFeature.PromptText, (b) => { if (b) { this.PrevConfirmed(); } }, okButtonText: _prevFeature.PromptConfirm, cancelButtonText: _prevFeature.PromptCancel); } }); }
private void HandleUpdatesForStartStations(ProgressResponse response, IEnumerable <PumpViewModel> pumps, int durationMinutes, string[] stationIds) { MainThreadUtility.InvokeOnMain(() => { if (response != null) { DataCache.AddCommandProgress(new CommandProgress(CommandType.StartStations, response.Body, stationIds)); if (response.IsFinal) { Action resetStations = () => { foreach (string id in stationIds) { var station = this.Device?.Device?.Stations.Values.Where((d) => d.Id == id).FirstOrDefault(); if (station != null) { station.Selected = false; station.Starting = false; } } }; if (response.IsSuccessful) { //AlertUtility.ShowAlert("Starting Stations", "Starting Stations"); this.RegisterForAsyncUpdate(resetStations, 5000); } else { this.RegisterForAsyncUpdate(resetStations); if ((bool)!response?.IsReconnectResponse && (bool)!response?.IsServerDownResponse) { AlertUtility.ShowAppError(response?.ErrorBody); } } DataCache.TriggerDeviceUpdate(this.DeviceId); } } }); }
public void SetUp() { _notifier = new Mock <INotificationService>(); _userCache = new Mock <ICurrentUserService>(); _nav = new Mock <INavigation>(); _alert = new AlertUtility((s1, s2, s3, s4) => Task.FromResult(false), (s1, s2, s3) => Task.Delay(0)); _logger = new Mock <MobileClient.Utilities.ILogger <FeedbackViewModel> >(); _pageFactory = new Mock <IPageFactory>(); _notifier.Setup(x => x.Notify(It.Is <NotificationRequest>(y => y.From == "*****@*****.**" && y.To == "*****@*****.**" && y.MessageType == MessageType.Email))); _userCache.Setup(x => x.GetLoggedInAccount()).Returns(new AccountModel() { Email = "*****@*****.**", UserId = "1234" }); _nav.Setup(x => x.PopAsync()).ReturnsAsync(null as Page); _mnNav = new MainThreadNavigator(x => x(), _nav.Object); }
public void SetUp() { _alertService = new Mock <IToastService>(); _purchaseService = new Mock <IPurchasingService>(); _subCache = new Mock <ICache <SubscriptionModel> >(); _subService = new Mock <ISubscriptionService>(); _userCache = new Mock <ICurrentUserService>(); _nav = new Mock <INavigation>(); _mnNav = new MainThreadNavigator(x => x(), _nav.Object); _validationModel = new ValidationModel() { RemainingOrders = 0, State = ValidationState.FreeReportValid }; _runtimePlatform = Device.Android; _navigateFromMenu = new Action <BaseNavPageType>(x => CurrentTab = x); _alertUtil = new AlertUtility((s1, s2, s3, s4) => Task.FromResult(false), (s1, s2, s3) => Task.Delay(0)); _openUri = new Action <Uri>(x => OpenedUri = x); }
protected virtual void OnAuthFailure() { ExceptionUtility.Try(() => { if (this.IsShowing) { //cancel reconnecting ConnectionManager.CancelReconnecting(); //clear cache Caches.ClearCachesForAuthFailure(); MainThreadUtility.InvokeOnMain(() => { //show alert ProgressUtility.Dismiss(); AlertUtility.ShowAlert(StringLiterals.AuthFailure, StringLiterals.AuthFailureMessage); //nav to login screen this.NavigateUserConfig(); }); } }); }
private void StartButton_TouchUpInside(object sender, EventArgs e) { ExceptionUtility.Try(() => { string title = _startPivot ? StringLiterals.StartStationConfirmationTitle : StringLiterals.StopProgramConfirmationTitle; AlertUtility.ShowConfirmationAlert(title, StringLiterals.FormatStartStopProgramConfirmationMessage(_startPivot, _programStart.Name, _programStart.Id), (b) => { if (b) { StopStartProgramConfirmed(_programStart, _startPivot); } else { var cell = this.GetCell(_programStart) as ProgramListTableViewCell; if (cell != null) { _programStart.Starting = false; cell.LoadCellValues(_programStart); } } }, okButtonText: _startPivot?StringLiterals.Start: StringLiterals.Stop); }); }
private void StopStartProgram(ProgramViewModel program, bool start) { ExceptionUtility.Try(() => { string title = start ? StringLiterals.StartStationConfirmationTitle : StringLiterals.StopProgramConfirmationTitle; AlertUtility.ShowConfirmationAlert(title, StringLiterals.FormatStartStopProgramConfirmationMessage(start, program.Name, program.Id), (b) => { if (b) { StopStartProgramConfirmed(program, start); } else { var cell = this._tableViewController.GetCell(program) as ProgramListTableViewCell; if (cell != null) { program.Starting = false; cell.LoadCellValues(program); } } }, okButtonText: start?StringLiterals.Start: StringLiterals.Stop); }); }
private void ShowError(string errorMsg) { AlertUtility.ShowAlert(StringLiterals.Error, errorMsg); }
private async void SubmitForm() { try { _connectingManually = true; if (this._navBarView.DoneButtonEnabled) { //var oldUsername = User.Current?.Username; //var oldPassword = User.Current?.Password; //var oldServerUri = User.Current?.ServerUri; var username = this._tableViewController.Username; var password = this._tableViewController.Password; var serverUri = this._tableViewController.ServerUri; //set default if no server uri provided if (String.IsNullOrEmpty(serverUri)) { serverUri = AppSettings.GetAppSettingValue(AppSettings.DefaultAppServerUriAppSettingName, String.Empty); this._tableViewController.ServerUri = serverUri; } //translate server alias to a uri serverUri = ServerAliases.AliasToUri(serverUri); bool newUser = false; bool newServer = false; if (User.Current == null) { User.Current = new User(); } else { //check if current user is different from prev user newUser = ((User.Current.Username != null) && User.Current.Username.Trim().ToLower() != username.Trim().ToLower()); newServer = ((User.Current.ServerUri != null) && User.Current.ServerUri.Trim().ToLower() != serverUri.Trim().ToLower()); } if (newServer || newUser) { await this.LogoutInternal(); } User.Current.Username = username; User.Current.Password = password; User.Current.ServerUri = serverUri; if (User.Current != null) { await ProgressUtility.SafeShow("Connecting to Server", async() => { //if reconnect process is running, cancel it if (ConnectionManager.IsReconnecting) { await ConnectionManager.CancelReconnecting(); } //here, if we are voluntarily connecting to a new server or new user, we must suppress the automatic reconnect attempt on closing connection if (newUser || newServer) { ConnectionManager.Deinitialize(); } WebSocketsClient.ResetWebSocketsClientUrl(new WebSocketsClientIos(), serverUri); ConnectionManager.Initialize(); var deviceListVc = DeviceListViewController.CreateInstance(); //test connection var response = await ServiceContainer.UserService.RequestConnection(username, password); ProgressUtility.Dismiss(); this.ShowError(response); if (response != null && response.IsSuccessful) { //only save the changes after successful login //User.Current.Save(); //this.NavigateTo(deviceListVc, inCurrentNavController: false); //PresentViewController(new AquamonixNavController(deviceListVc), true, null); LogUtility.Enabled = true; } else { if (response?.ErrorBody != null && response.ErrorBody.ErrorType == ErrorResponseType.ConnectionTimeout) { if (DataCache.HasDevices) { deviceListVc.ShowConnectionError = true; this.NavigateTo(deviceListVc, inCurrentNavController: false); } else { AlertUtility.ShowErrorAlert(StringLiterals.ConnectionError, StringLiterals.UnableToEstablishConnection); ConnectionManager.CancelReconnecting(); } } // Edited // if (response?.ErrorBody != null && response.ErrorBody.ErrorType == ErrorResponseType.AuthFailure) { AlertUtility.ShowErrorAlert(StringLiterals.ConnectionError, StringLiterals.AuthFailureMessage); Caches.ClearCachesForAuthFailure(); } this.LoadData(); } }); } } } catch (Exception e) { LogUtility.LogException(e); } }
/// <summary> /// The most important method of this class; makes a server call and then asynchronously waits for the response. /// </summary> /// <param name="request">The request object</param> /// <param name="onConnectionResume">Action to execute if the connection is broken, then resumed, during execution of this call.</param> /// <param name="silentMode">If true, will not display any popups or alerts for any reason.</param> /// <returns>Task result with the response</returns> public async Task <TResponse> DoRequestAsync <TRequest, TResponse>(TRequest request, Action onConnectionResume, bool silentMode = false) where TRequest : IApiRequest where TResponse : IApiResponse, new() { TResponse response = default(TResponse); try { bool cancelRequest = false; //is connection closed? if (_client.ReadyState == ReadyState.Closed || _client.ReadyState == ReadyState.Closing) { if (!(request is Aquamonix.Mobile.Lib.Domain.Requests.ConnectionRequest)) { this.FireRequestFailureEvent(request, null, RequestFailureReason.Network, onConnectionResume, (!silentMode)); cancelRequest = true; } else { _client.Dispose(); this.SetUrl(_url); } } if (!cancelRequest) { //attempt to open connection if not already if (_client.ReadyState != ReadyState.Open) { bool opened = await this.Open(request.Header.Channel, silentMode); if (!opened) { //if not a connection request, we want to fire an event if (!(request is Aquamonix.Mobile.Lib.Domain.Requests.ConnectionRequest)) { //fire the event this.FireRequestFailureEvent(request, null, RequestFailureReason.Network, onConnectionResume, !(silentMode)); } return(ResponseFactory.FabricateConnectionTimeoutResponse <TResponse>(request)); } //NEW: this 'else' clause is new else { //if not a connection request, then we want to make a connection request now if (!(request is Aquamonix.Mobile.Lib.Domain.Requests.ConnectionRequest)) { // make a request connection, if it fails it doesnt matter as it will be picked up below await ServiceContainer.UserService.RequestConnection( User.Current.Username, User.Current.Password, silentMode : true ); } } } //send the request and wait for response response = await this.Send <TResponse>(request, request.Header.Channel, silentMode); //if response is null or unsuccessful, handle if (response == null || !response.IsSuccessful) { if (response != null && response.IsReconnectResponse) { LogUtility.LogMessage("Received a Reconnect response from server; will reconnect"); this.FireRequestFailureEvent(request, response, RequestFailureReason.ServerRequestedReconnect, onConnectionResume, (!silentMode)); } else { //if response is a timeout, handle if (response != null && response.IsTimeout) { this.FireRequestFailureEvent(request, response, RequestFailureReason.Timeout, onConnectionResume, (!silentMode)); } else { if (response != null) { //if server is down, handle if (response.IsServerDownResponse) { this.FireRequestFailureEvent(request, response, RequestFailureReason.ServerDown, onConnectionResume, (!silentMode)); } else if (response.IsAuthFailure) { this.FireRequestFailureEvent(request, response, RequestFailureReason.Auth, onConnectionResume, (!silentMode)); } else { this.FireRequestFailureEvent(request, response, RequestFailureReason.Error, onConnectionResume, (!silentMode)); //show error AlertUtility.ShowAppError(response?.ErrorBody); } } else { this.FireRequestSucceededEvent(request, response); } } } } else { this.FireRequestSucceededEvent(request, response); } } } catch (Exception e) { LogUtility.LogException(e); } return(response); }
//edited private void DismissAlertsConfirmed() { ExceptionUtility.Try(() => { if (this.HasAccessLevelToDelete()) { if (String.IsNullOrEmpty(_searchBoxView.Text)) { //var activeAlertIds = this.GetActiveAlertIds(); var activeAlerts = GetActiveAlert(); //check all the active alers have correct access with device var deletingAlertsIds = CheckAlertDeletePermission(activeAlerts); if (deletingAlertsIds.Count < activeAlerts.Count()) { AlertUtility.ShowConfirmationAlert(StringLiterals.Alert, StringLiterals.ActiveAlertsNotAccessForDissmiss(), (b) => { if (b) { ServiceContainer.AlertService.DismissGlobalAlerts(deletingAlertsIds, onReconnect: () => { DismissAlertsConfirmed(); }).ContinueWith((r) => { MainThreadUtility.InvokeOnMain(() => { ProgressUtility.Dismiss(); }); }); } }, StringLiterals.Dismiss); } else { ServiceContainer.AlertService.DismissGlobalAlerts(deletingAlertsIds, onReconnect: () => { DismissAlertsConfirmed(); }).ContinueWith((r) => { MainThreadUtility.InvokeOnMain(() => { ProgressUtility.Dismiss(); }); }); } } else { //var activeAlertIds = this.GetActiveAlertIds(); var activeAlerts = GetActiveAlertsFromSearchList(); //check all the active alers have correct access with device var deletingAlertsIds = CheckAlertDeletePermission(activeAlerts); if (deletingAlertsIds.Count < activeAlerts.Count()) { AlertUtility.ShowConfirmationAlert(StringLiterals.Alert, StringLiterals.ActiveAlertsNotAccessForDissmiss(), (b) => { if (b) { ServiceContainer.AlertService.DismissGlobalAlerts(deletingAlertsIds, onReconnect: () => { DismissAlertsConfirmed(); }).ContinueWith((r) => { MainThreadUtility.InvokeOnMain(() => { ProgressUtility.Dismiss(); }); }); } }, StringLiterals.Dismiss); } else { ServiceContainer.AlertService.DismissGlobalAlerts(deletingAlertsIds, onReconnect: () => { DismissAlertsConfirmed(); }).ContinueWith((r) => { MainThreadUtility.InvokeOnMain(() => { ProgressUtility.Dismiss(); }); }); } } } }); }
public VehicleController(ILogger <VehicleController> logger, IRepositoryWrapper repositoryWrapper) { _logger = logger; repository = repositoryWrapper; alertU = new AlertUtility(repositoryWrapper); }