mirror of
https://dev.azure.com/TeilRad/sharee.bike%20App/_git/Code
synced 2024-11-05 10:36:30 +01:00
336 lines
13 KiB
C#
336 lines
13 KiB
C#
using MonkeyCache.FileStore;
|
|
using System;
|
|
using System.Threading.Tasks;
|
|
using TINK.Repository.Request;
|
|
using TINK.Repository.Response;
|
|
using TINK.Model.Services.CopriApi;
|
|
using TINK.Model.Device;
|
|
|
|
namespace TINK.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"" : ""4.1.0.0"",
|
|
""bikes"" : {},
|
|
""response_state"" : ""OK"",
|
|
""apiserver"" : ""https://app.tink-konstanz.de"",
|
|
""authcookie"" : """",
|
|
""response"" : ""bikes_available""
|
|
}";
|
|
|
|
/// <summary> Gets an empty response. </summary>
|
|
/// <param name="copriVersion">Version of empty response.</param>
|
|
/// <returns>Response.</returns>
|
|
public static BikesAvailableResponse GetEmptyBikesAvailableResponse(string copriVersion)
|
|
=> JsonConvertRethrow.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE.Replace("4.1.0.0", copriVersion));
|
|
|
|
#if !COPRIVERSION41
|
|
public const string BIKESOCCUPIED = @"{
|
|
""debuglevel"" : ""1"",
|
|
""user_id"" : """",
|
|
""response"" : ""user_bikes_occupied"",
|
|
""user_group"" : [ ""Konrad"", ""TINK"" ],
|
|
""authcookie"" : """",
|
|
""response_state"" : ""OK"",
|
|
""bikes_occupied"" : {},
|
|
""copri_version"" : ""4.1.0.0"",
|
|
""apiserver"" : ""https://app.tink-konstanz.de""
|
|
}";
|
|
#endif
|
|
|
|
/// <summary> Gets an empty response. </summary>
|
|
/// <param name="copriVersion">Version of empty response.</param>
|
|
/// <returns>Response.</returns>
|
|
public static BikesReservedOccupiedResponse GetEmptyBikesReservedOccupiedResponse(string copriVersion)
|
|
=> JsonConvertRethrow.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED.Replace("4.1.0.0", copriVersion));
|
|
|
|
#if !COPRIVERSION41
|
|
/// <summary> Version COPRI 4.0. or earlier</summary>
|
|
public const string STATIONSALL = @"{
|
|
""apiserver"" : """",
|
|
""authcookie"" : """",
|
|
""response"" : ""stations_all"",
|
|
""copri_version"" : ""4.1.0.0"",
|
|
""stations"" : {},
|
|
""response_state"" : ""OK""
|
|
}";
|
|
#else
|
|
/// <summary> Version COPRI 4.1 or later. </summary>
|
|
public const string STATIONSALL = @"{
|
|
""uri_primary"": """"
|
|
""uri_operator_array"": [ ]
|
|
""authcookie"" : """",
|
|
""response"" : ""stations_all"",
|
|
""copri_version"" : ""4.1.0.0"",
|
|
""stations"" : {},
|
|
""response_state"" : ""OK""
|
|
}";
|
|
#endif
|
|
|
|
#if !COPRIVERSION41
|
|
/// <summary> Version COPRI 4.0. or earlier</summary>
|
|
public const string AUTHORIZATION = @"{
|
|
""user_group"" : [ """" ],
|
|
""response"" : ""authorization"",
|
|
""response_state"" : ""OK"",
|
|
""copri_version"" : ""4.1.0.0""
|
|
}";
|
|
#else
|
|
/// <summary> Version COPRI 4.0. or earlier</summary>
|
|
public const string AUTHORIZATION = @"{
|
|
""user_group"" : [],
|
|
""response"" : ""authorization"",
|
|
""response_state"" : ""OK"",
|
|
""copri_version"" : ""4.1.0.0""
|
|
}";
|
|
#endif
|
|
|
|
/// <summary> Gets an empty response. </summary>
|
|
/// <param name="copriVersion">Version of empty response.</param>
|
|
/// <returns>Response.</returns>
|
|
public static StationsAllResponse GetEmptyStationsAllResponse(string copriVersion)
|
|
=> JsonConvertRethrow.DeserializeObject<StationsAllResponse>(STATIONSALL.Replace("4.1.0.0", copriVersion));
|
|
|
|
/// <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(JsonConvertRethrow.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(JsonConvertRethrow.DeserializeObject<BikesReservedOccupiedResponse>(BIKESOCCUPIED), new TimeSpan(0));
|
|
}
|
|
|
|
if (!Barrel.Current.Exists(requestBuilder.GetStations()))
|
|
{
|
|
AddToCache(JsonConvertRethrow.DeserializeObject<StationsAllResponse>(STATIONSALL), new TimeSpan(0));
|
|
}
|
|
}
|
|
|
|
public Task<ReservationBookingResponse> DoReserveAsync(string bikeId, Uri operatorUri)
|
|
{
|
|
throw new System.Exception("Reservierung im Offlinemodus nicht möglich!");
|
|
}
|
|
|
|
public Task<ReservationCancelReturnResponse> DoCancelReservationAsync(string bikeId, Uri operatorUri)
|
|
{
|
|
throw new System.Exception("Abbrechen einer Reservierung im Offlinemodus nicht möglich!");
|
|
}
|
|
|
|
public Task<ReservationBookingResponse> CalculateAuthKeysAsync(string bikeId, Uri operatorUri)
|
|
=> throw new System.Exception("Schlosssuche im Offlinemodus nicht möglich!");
|
|
|
|
public Task<ReservationBookingResponse> UpdateLockingStateAsync(
|
|
string 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(string bikeId, Guid guid, double batteryPercentage, Uri operatorUri)
|
|
{
|
|
throw new System.Exception("Buchung im Offlinemodus nicht möglich!");
|
|
}
|
|
|
|
public Task<ReservationCancelReturnResponse> DoReturn(
|
|
string bikeId,
|
|
LocationDto geolocation,
|
|
ISmartDevice smartDevice,
|
|
Uri operatorUri)
|
|
{
|
|
throw new System.Exception("Rückgabe im Offlinemodus nicht möglich!");
|
|
}
|
|
|
|
public Task<SubmitFeedbackResponse> DoSubmitFeedback(string bikeId, 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(),
|
|
JsonConvertRethrow.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(),
|
|
JsonConvertRethrow.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(),
|
|
JsonConvertRethrow.SerializeObject(bikes),
|
|
expiresAfter);
|
|
}
|
|
}
|
|
}
|
|
}
|