sharee.bike-App/TINKLib/Repository/CopriCallsMonkeyStore.cs

282 lines
11 KiB
C#
Raw Normal View History

2021-05-13 20:03:07 +02:00
using MonkeyCache.FileStore;
using System;
using System.Threading.Tasks;
using TINK.Model.Connector;
using TINK.Model.Repository.Request;
using TINK.Model.Repository.Response;
using TINK.Model.Services.CopriApi;
using TINK.Repository.Response;
namespace TINK.Model.Repository
{
public class CopriCallsMonkeyStore : ICopriCache
{
/// <summary> Prevents concurrent communictation. </summary>
private object monkeyLock = new object();
/// <summary> Builds requests.</summary>
private IRequestBuilder requestBuilder;
public const string BIKESAVAILABLE = @"{
""copri_version"" : ""3.0.0.0"",
""bikes"" : {},
""response_state"" : ""OK"",
""apiserver"" : ""https://app.tink-konstanz.de"",
""authcookie"" : """",
""response"" : ""bikes_available""
}";
public const string BIKESOCCUPIED = @"{
""debuglevel"" : ""1"",
""user_id"" : """",
""response"" : ""user_bikes_occupied"",
""user_group"" : ""Konrad,TINK"",
""authcookie"" : """",
""response_state"" : ""OK"",
""bikes_occupied"" : {},
""copri_version"" : ""3.0.0.0"",
""apiserver"" : ""https://app.tink-konstanz.de""
}";
public const string STATIONS = @"{
""apiserver"" : ""https://app.tink-konstanz.de"",
""authcookie"" : """",
""response"" : ""stations_all"",
""copri_version"" : ""3.0.0.0"",
""stations"" : {},
""response_state"" : ""OK""
}";
/// <summary>
/// Holds the seconds after which station and bikes info is considered to be invalid.
/// Default value 1s.
/// </summary>
private TimeSpan ExpiresAfter { get; }
/// <summary> Returns false because cached values are returned. </summary>
public bool IsConnected => false;
/// <summary> Gets the merchant id.</summary>
public string MerchantId => requestBuilder.MerchantId;
/// <summary> Gets the merchant id.</summary>
public string SessionCookie => requestBuilder.SessionCookie;
/// <summary> Initializes a instance of the copri monkey store object. </summary>
/// <param name="p_strMerchantId">Id of the merchant.</param>
/// <param name="sessionCookie">Session cookie if user is logged in, null otherwise.</param>
public CopriCallsMonkeyStore(
string merchantId,
string sessionCookie = null,
TimeSpan? expiresAfter = null)
{
ExpiresAfter = expiresAfter ?? TimeSpan.FromSeconds(1);
requestBuilder = string.IsNullOrEmpty(sessionCookie)
? new RequestBuilder(merchantId) as IRequestBuilder
: new RequestBuilderLoggedIn(merchantId, sessionCookie);
// Ensure that store holds valid entries.
if (!Barrel.Current.Exists(requestBuilder.GetBikesAvailable()))
{
AddToCache(JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE), new TimeSpan(0));
}
// Do not query bikes occupied if no user is logged in (leads to not implemented exception)
if (!string.IsNullOrEmpty(sessionCookie) && !Barrel.Current.Exists(requestBuilder.GetBikesOccupied()))
{
AddToCache(JsonConvert.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED), new TimeSpan(0));
}
if (!Barrel.Current.Exists(requestBuilder.GetStations()))
{
AddToCache(JsonConvert.DeserializeObject<StationsAllResponse>(STATIONS), new TimeSpan(0));
}
}
public Task<ReservationBookingResponse> DoReserveAsync(int bikeId, Uri operatorUri)
{
throw new System.Exception("Reservierung im Offlinemodus nicht möglich!");
}
public Task<ReservationCancelReturnResponse> DoCancelReservationAsync(int p_iBikeId, Uri operatorUri)
{
throw new System.Exception("Abbrechen einer Reservierung im Offlinemodus nicht möglich!");
}
public Task<ReservationBookingResponse> CalculateAuthKeysAsync(int bikeId, Uri operatorUri)
=> throw new System.Exception("Schlosssuche im Offlinemodus nicht möglich!");
public Task<ReservationBookingResponse> UpdateLockingStateAsync(
int bikeId,
LocationDto geolocation,
lock_state state,
double batteryLevel,
Uri operatorUri)
=> throw new System.Exception("Aktualisierung des Schlossstatuses im Offlinemodus nicht möglich!");
public Task<ReservationBookingResponse> DoBookAsync(int bikeId, Guid guid, double batteryPercentage, Uri operatorUri)
{
throw new System.Exception("Buchung im Offlinemodus nicht möglich!");
}
public Task<ReservationCancelReturnResponse> DoReturn(int bikeId, LocationDto geolocation, Uri operatorUri)
{
throw new System.Exception("Rückgabe im Offlinemodus nicht möglich!");
}
public Task<SubmitFeedbackResponse> DoSubmitFeedback(string message, bool isBikeBroken, Uri operatorUri) =>
throw new System.Exception("Übermittlung von Feedback im Offlinemodus nicht möglich!");
public Task<AuthorizationResponse> DoAuthorizationAsync(string p_strMailAddress, string p_strPassword, string p_strDeviceId)
{
throw new System.Exception("Anmelden im Offlinemodus nicht möglich!");
}
public Task<AuthorizationoutResponse> DoAuthoutAsync()
{
throw new System.Exception("Abmelden im Offlinemodus nicht möglich!");
}
public async Task<BikesAvailableResponse> GetBikesAvailableAsync()
{
var l_oBikesAvailableTask = new TaskCompletionSource<BikesAvailableResponse>();
lock (monkeyLock)
{
l_oBikesAvailableTask.SetResult(Barrel.Current.Get<BikesAvailableResponse>(requestBuilder.GetBikesAvailable()));
}
return await l_oBikesAvailableTask.Task;
}
public async Task<BikesReservedOccupiedResponse> GetBikesOccupiedAsync()
{
try
{
var l_oBikesOccupiedTask = new TaskCompletionSource<BikesReservedOccupiedResponse>();
lock (monkeyLock)
{
l_oBikesOccupiedTask.SetResult(Barrel.Current.Get<BikesReservedOccupiedResponse>(requestBuilder.GetBikesOccupied()));
}
return await l_oBikesOccupiedTask.Task;
}
catch (NotSupportedException)
{
// No user logged in.
await Task.CompletedTask;
return ResponseHelper.GetBikesOccupiedNone();
}
}
public async Task<StationsAllResponse> GetStationsAsync()
{
var l_oStationsAllTask = new TaskCompletionSource<StationsAllResponse>();
lock (monkeyLock)
{
l_oStationsAllTask.SetResult(Barrel.Current.Get<StationsAllResponse>(requestBuilder.GetStations()));
}
return await l_oStationsAllTask.Task;
}
/// <summary> Gets a value indicating whether stations are expired or not.</summary>
public bool IsStationsExpired
{
get
{
lock (monkeyLock)
{
return Barrel.Current.IsExpired(requestBuilder.GetStations());
}
}
}
/// <summary> Adds a stations all response to cache.</summary>
/// <param name="stations">Stations to add.</param>
public void AddToCache(StationsAllResponse stations)
{
AddToCache(stations, ExpiresAfter);
}
/// <summary> Adds a stations all response to cache.</summary>
/// <param name="stations">Stations to add.</param>
/// <param name="expiresAfter">Time after which anser is considered to be expired.</param>
private void AddToCache(StationsAllResponse stations, TimeSpan expiresAfter)
{
lock (monkeyLock)
{
Barrel.Current.Add(
requestBuilder.GetStations(),
JsonConvert.SerializeObject(stations),
expiresAfter);
}
}
/// <summary> Gets a value indicating whether stations are expired or not.</summary>
public bool IsBikesAvailableExpired
{
get
{
lock (monkeyLock)
{
return Barrel.Current.IsExpired(requestBuilder.GetBikesAvailable());
}
}
}
/// <summary> Adds a bikes response to cache.</summary>
/// <param name="bikes">Bikes to add.</param>
public void AddToCache(BikesAvailableResponse bikes)
{
AddToCache(bikes, ExpiresAfter);
}
/// <summary> Adds a bikes response to cache.</summary>
/// <param name="bikes">Bikes to add.</param>
/// <param name="expiresAfter">Time after which anser is considered to be expired.</param>
private void AddToCache(BikesAvailableResponse bikes, TimeSpan expiresAfter)
{
lock (monkeyLock)
{
Barrel.Current.Add(
requestBuilder.GetBikesAvailable(),
JsonConvert.SerializeObject(bikes),
expiresAfter);
}
}
/// <summary> Gets a value indicating whether stations are expired or not.</summary>
public bool IsBikesOccupiedExpired
{
get
{
lock (monkeyLock)
{
return Barrel.Current.IsExpired(requestBuilder.GetBikesOccupied());
}
}
}
/// <summary> Adds a bikes response to cache.</summary>
/// <param name="bikes">Bikes to add.</param>
public void AddToCache(BikesReservedOccupiedResponse bikes)
{
AddToCache(bikes, ExpiresAfter);
}
/// <summary> Adds a bikes response to cache.</summary>
/// <param name="bikes">Bikes to add.</param>
/// <param name="expiresAfter">Time after which anser is considered to be expired.</param>
private void AddToCache(BikesReservedOccupiedResponse bikes, TimeSpan expiresAfter)
{
lock (monkeyLock)
{
Barrel.Current.Add(
requestBuilder.GetBikesOccupied(),
JsonConvert.SerializeObject(bikes),
expiresAfter);
}
}
}
}