sharee.bike-App/TINKLib/ViewModel/Bikes/Bike/CopriLock/RequestHandler/BookedClosed.cs

using System;
using System.Threading.Tasks;
using Serilog;
using TINK.Model.Bikes.BikeInfoNS.CopriLock;
using TINK.Model.Connector;
using TINK.Model.Device;
using TINK.Model.User;
using TINK.MultilingualResources;
using TINK.Repository.Exception;
using TINK.View;

namespace TINK.ViewModel.Bikes.Bike.CopriLock.RequestHandler
{
    using IRequestHandler = BluetoothLock.IRequestHandler;

    public class BookedClosed : Base, IRequestHandler
    {
        /// <param name="smartDevice">Provides info about the smart device (phone, tablet, ...)</param>
        /// <param name="bikesViewModel">View model to be used for progress report and unlocking/ locking view.</param>
        public BookedClosed(
           IBikeInfoMutable selectedBike,
           Func<bool> isConnectedDelegate,
           Func<bool, IConnector> connectorFactory,
           Func<IPollingUpdateTaskManager> viewUpdateManager,
           ISmartDevice smartDevice,
           IViewService viewService,
           IBikesViewModel bikesViewModel,
           IUser activeUser) : base(
               selectedBike,
               nameof(BookedClosed),
               false, // Lock can only be closed manually and returning is performed by placing bike into the station.
               isConnectedDelegate,
               connectorFactory,
               viewUpdateManager,
               smartDevice,
               viewService,
               bikesViewModel,
               activeUser)
        {
            LockitButtonText = AppResources.ActionOpenAndPause;
            IsLockitButtonVisible = true; // Show button to enable opening lock in case user took a pause and does not want to return the bike.
        }

        /// <summary> Return bike. </summary>
        public async Task<IRequestHandler> HandleRequestOption1() => await UnsupportedRequest();

        /// <summary> Open bike and update COPRI lock state. </summary>
        public async Task<IRequestHandler> HandleRequestOption2() => await OpenLock();

        /// <summary> Requst is not supported, button should be disabled. </summary>
        public async Task<IRequestHandler> UnsupportedRequest()
        {
            Log.ForContext<BookedClosed>().Error("Click of unsupported button click detected.");
            return await Task.FromResult<IRequestHandler>(this);
        }

        /// <summary> Open bike. </summary>
        public async Task<IRequestHandler> OpenLock()
        {
            // Unlock bike.
            Log.ForContext<BookedClosed>().Information("User request to unlock bike {bike}.", SelectedBike);

            // Stop polling before returning bike.
            BikesViewModel.IsIdle = false;
            BikesViewModel.ActionText = AppResources.ActivityTextOneMomentPlease;
            await ViewUpdateManager().StopUpdatePeridically();

            BikesViewModel.ActionText = AppResources.ActivityTextOpeningLock;
            IsConnected = IsConnectedDelegate();
            try
            {
                await ConnectorFactory(IsConnected).Command.OpenLockAsync(SelectedBike);
            }
            catch (Exception exception)
            {
                BikesViewModel.ActionText = string.Empty;

                if (exception is WebConnectFailureException)
                {
                    // Copri server is not reachable.
                    Log.ForContext<BookedClosed>().Information("User selected bike {id} but opening lock failed (Copri server not reachable).", SelectedBike.Id);

                    await ViewService.DisplayAdvancedAlert(
                        AppResources.MessageOpeningLockErrorConnectionTitle,
                        WebConnectFailureException.GetHintToPossibleExceptionsReasons,
                        exception.Message,
                        AppResources.MessageAnswerOk);
                }
                else
                {
                    Log.ForContext<BookedClosed>().Error("Lock can not be opened. {Exception}", exception);

                    await ViewService.DisplayAlert(
                        AppResources.ErrorOpenLockTitle,
                        exception.Message,
                        AppResources.MessageAnswerOk);
                }

                BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
                await ViewUpdateManager().StartUpdateAyncPeridically();
                BikesViewModel.ActionText = string.Empty;
                BikesViewModel.IsIdle = true;
                return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
            }

            Log.ForContext<BookedClosed>().Information("User paused ride using {bike} successfully.", SelectedBike);
            BikesViewModel.ActionText = AppResources.ActivityTextStartingUpdater;
            await ViewUpdateManager().StartUpdateAyncPeridically();
            BikesViewModel.ActionText = string.Empty;
            BikesViewModel.IsIdle = true;
            return RequestHandlerFactory.Create(SelectedBike, IsConnectedDelegate, ConnectorFactory, ViewUpdateManager, SmartDevice, ViewService, BikesViewModel, ActiveUser);
        }
    }
}