sharee.bike-App/TestTINKLib/Mocks/Connector/CopriCallsCacheMemory.cs

using System;
using System.Threading.Tasks;
using TINK.Model.Services.CopriApi;
using TINK.Repository;
using TINK.Repository.Response;
using static TINK.Repository.CopriCallsMemory;
using TINK.Repository.Request;
using TINK.Model.Device;
using System.Collections.Generic;

namespace TestTINKLib.Mocks.Connector
{
    /// <summary> Allows use of memory for retrieving defined respones.</summary>
    public class CopriCallsCacheMemory : ICopriCache
    {
        private CopriCallsMemory server; 

        public CopriCallsCacheMemory(
            SampleSets? sampleSet = null,
            int? index = null,
            string sessionCookie = null)
        {
            server = new CopriCallsMemory(sampleSet, index, sessionCookie);
        }

        public bool IsStationsExpired => true;

        public bool IsBikesAvailableExpired => true;

        public bool IsBikesOccupiedExpired => true;

        public bool IsConnected => server.IsConnected;

        public string SessionCookie => server.SessionCookie;

        public string MerchantId => server.MerchantId;

        public void AddToCache(StationsAvailableResponse stations)
        {
            return;
        }

        public void AddToCache(BikesAvailableResponse bikes)
        {
            return;
        }

        public void AddToCache(BikesReservedOccupiedResponse bikes)
        {
            return;
        }

        public Task<AuthorizationResponse> DoAuthorizationAsync(string p_strMailAddress, string p_strPassword, string p_strDeviceId)
        {
            throw new NotImplementedException();
        }

        public Task<AuthorizationoutResponse> DoAuthoutAsync()
        {
            throw new NotImplementedException();
        }

        public Task<ReservationBookingResponse> DoReserveAsync(string bikeId, Uri operatorUri)
        {
            throw new NotImplementedException();
        }

        public Task<ReservationCancelReturnResponse> DoCancelReservationAsync(string p_iBikeId, Uri operatorUri)
        {
            throw new NotImplementedException();
        }

        public Task<ReservationBookingResponse> CalculateAuthKeysAsync(string bikeId, Uri operatorUri)
            => throw new NotSupportedException();

        public Task<ResponseBase> StartReturningBike(
            string bikeId,
            Uri operatorUri)
            => throw new NotImplementedException();

        public Task<ReservationBookingResponse> UpdateLockingStateAsync(
            string bikeId, 
            lock_state state, 
            Uri operatorUri,
            LocationDto geolocation, 
            double batteryPercentage)
            => throw new NotImplementedException();

        public Task<ReservationBookingResponse> DoBookAsync(string bikeId, Guid guid, double batteryPercentage, Uri operatorUri)
            => throw new NotImplementedException();

        public Task<ReservationBookingResponse> BookAndStartOpeningAsync(string bikeId, Uri operatorUri)
            => throw new NotImplementedException();

        public Task<DoReturnResponse> DoReturn(string bikeId, LocationDto location, ISmartDevice smartDevice, Uri operatorUri)
            => throw new NotImplementedException();

        /// <summary> Returns a bike and starts closing. </summary>
        /// <param name="bikeId">Id of the bike to return.</param>
        /// <param name="smartDevice">Provides info about hard and software.</param>
        /// <param name="operatorUri">Holds the uri of the operator or null, in case of single operator setup.</param>
        /// <returns>Response on returning request.</returns>
        public Task<DoReturnResponse> ReturnAndStartClosingAsync(
            string bikeId,
            ISmartDevice smartDevice,
            Uri operatorUri)
            => throw new System.Exception("Rückgabe mit mit Schloss schließen Befehl Offlinemodus nicht möglich!");

        public Task<SubmitFeedbackResponse> DoSubmitFeedback(string bikeId, string message, bool isBikeBroken, Uri operatorUri)
            => throw new NotImplementedException();

        /// <summary> Submits mini survey to copri server. </summary>
        /// <param name="answers">Collection of answers.</param>
        public Task<ResponseBase> DoSubmitMiniSurvey(IDictionary<string, string> answers)
            => throw new NotImplementedException();

        public Task<BikesAvailableResponse> GetBikesAvailableAsync()
        {
            return server.GetBikesAvailableAsync();
        }

        public Task<BikesReservedOccupiedResponse> GetBikesOccupiedAsync()
        {
            return server.GetBikesOccupiedAsync();
        }

        public Task<StationsAvailableResponse> GetStationsAsync()
        {
            return server.GetStationsAsync();
        }
    }
}