sharee.bike-App/TINKLib/Model/Connector/Updater/UpdaterJSON.cs

using System;
using System.Collections.Generic;
using Serilog;
using TINK.Model.Bikes;
using TINK.Model.State;
using TINK.Model.Station;
using TINK.Model.Station.Operator;
using TINK.Model.User.Account;
using TINK.Repository.Exception;
using TINK.Repository.Response;
using TINK.Services.CopriApi;
using Xamarin.Forms;
using BikeInfo = TINK.Model.Bikes.BikeInfoNS.BC.BikeInfo;
using IBikeInfoMutable = TINK.Model.Bikes.BikeInfoNS.BC.IBikeInfoMutable;

namespace TINK.Model.Connector.Updater
{
	/// <summary>
	/// Connects TINK app to copri using JSON as input data format.
	/// </summary>
	/// <todo>Rename to UpdateFromCopri.</todo>
	public static class UpdaterJSON
	{
		/// <summary> Loads a bike object from copri server cancel reservation/ booking update request.</summary>
		/// <param name="bike">Bike object to load response into.</param>
		/// <param name="notifyLevel">Controls whether notify property changed events are fired or not.</param>
		public static void Load(
			this IBikeInfoMutable bike,
			Bikes.BikeInfoNS.BC.NotifyPropertyChangedLevel notifyLevel)
		{

			bike.State.Load(InUseStateEnum.Disposable, notifyLevel: notifyLevel);
		}

		/// <summary>
		/// Gets all statsion for station provider and add them into station list.
		/// </summary>
		/// <param name="p_oStationList">List of stations to update.</param>
		public static StationDictionary GetStationsAllMutable(this StationsAvailableResponse stationsAllResponse)
		{
			// Get stations from Copri/ file/ memory, ....
			if (stationsAllResponse == null
				|| stationsAllResponse.stations == null)
			{
				// Latest list of stations could not be retrieved from provider.
				return new StationDictionary();
			}

			Version.TryParse(stationsAllResponse.copri_version, out Version copriVersion);

			var stations = new StationDictionary(p_oVersion: copriVersion);

			foreach (var station in stationsAllResponse.stations)
			{
				if (stations.GetById(station.Value.station) != null)
				{
					// Can not add station to list of station. Id is not unique.
					throw new InvalidResponseException<StationsAvailableResponse>(
						string.Format("Station id {0} is not unique.", station.Value.station), stationsAllResponse);
				}

				stations.Add(new Station.Station(
					station.Value.station,
					station.Value.GetGroup(),
					station.Value.GetPosition(),
					station.Value.description,
					new Data(station.Value.operator_data?.operator_name,
						station.Value.operator_data?.operator_phone,
						station.Value.operator_data?.operator_hours,
						station.Value.operator_data?.operator_email,
						!string.IsNullOrEmpty(station.Value.operator_data?.operator_color)
							? Color.FromHex(station.Value.operator_data?.operator_color)
							: (Color?)null)));
			}

			return stations;
		}

		/// <summary>
		/// Gets general data from COPRI response.
		/// </summary>
		/// <param name="response">Response to get data from.</param>
		/// <returns>General data object initialized form COPRI response.</returns>
		public static GeneralData GetGeneralData(this ResponseBase response)
			 => new GeneralData(
				 response.init_map.GetMapSpan(),
				 response.merchant_message,
				 response.TryGetCopriVersion(out Version copriVersion)
					? new Version(0, 0)
					: copriVersion,
				 new ResourceUrls(response.tariff_info_html, response.bike_info_html, response.agb_html, response.privacy_html, response.impress_html));

		/// <summary> Gets account object from login response.</summary>
		/// <param name="merchantId">Needed to extract cookie from autorization response.</param>
		/// <param name="loginResponse">Response to get session cookie and debug level from.</param>
		/// <param name="mail">Mail address needed to construct a complete account object (is not part of response).</param>
		/// <param name="password">Password needed to construct a complete account object (is not part of response).</param>
		public static IAccount GetAccount(
			this AuthorizationResponse loginResponse,
			string merchantId,
			string mail,
			string password)
		{
			if (loginResponse == null)
			{
				throw new ArgumentNullException(nameof(loginResponse));
			}

			return new Account(
				mail,
				password,
				loginResponse.GetIsAgbAcknowledged(),
				loginResponse.authcookie?.Replace(merchantId, ""),
				loginResponse.GetGroup(),
				loginResponse.debuglevel == 1
					? Permissions.All :
					(Permissions)loginResponse.debuglevel);
		}

		/// <summary> Load bike object from booking response. </summary>
		/// <param name="bike">Bike object to load from response.</param>
		/// <param name="bikeInfo">Booking response.</param>
		/// <param name="mailAddress">Mail address of user which books bike.</param>
		/// <param name="notifyLevel">Controls whether notify property changed events are fired or not.</param>
		public static void Load(
			this IBikeInfoMutable bike,
			BikeInfoReservedOrBooked bikeInfo,
			string mailAddress,
			Bikes.BikeInfoNS.BC.NotifyPropertyChangedLevel notifyLevel = Bikes.BikeInfoNS.BC.NotifyPropertyChangedLevel.All)
		{
			if (bike is Bikes.BikeInfoNS.BluetoothLock.BikeInfoMutable btBikeInfo)
			{
				btBikeInfo.LockInfo.Load(
					bikeInfo.GetBluetoothLockId(),
					bikeInfo.GetBluetoothLockGuid(),
					bikeInfo.GetSeed(),
					bikeInfo.GetUserKey(),
					bikeInfo.GetAdminKey());
			}

			var l_oState = bikeInfo.GetState();
			switch (l_oState)
			{
				case InUseStateEnum.Disposable:
					bike.State.Load(
						InUseStateEnum.Disposable,
						notifyLevel: notifyLevel);
					break;

				case InUseStateEnum.Reserved:
					bike.State.Load(
						InUseStateEnum.Reserved,
						bikeInfo.GetFrom(),
						mailAddress,
						bikeInfo.timeCode,
						notifyLevel);
					break;

				case InUseStateEnum.Booked:
					bike.State.Load(
						InUseStateEnum.Booked,
						bikeInfo.GetFrom(),
						mailAddress,
						bikeInfo.timeCode,
						notifyLevel);
					break;

				default:
					throw new Exception(string.Format("Unexpected bike state detected. state is {0}.", l_oState));
			}
		}

		/// <summary> Gets bikes available from copri server response.</summary>
		/// <param name="bikesAvailableResponse">Response to create collection from.</param>
		/// <returns>New collection of available bikes.</returns>
		public static BikeCollection GetBikesAvailable(
			this BikesAvailableResponse bikesAvailableResponse)
			=> GetBikesAll(
				bikesAvailableResponse?.bikes?.Values,
				new BikesReservedOccupiedResponse()?.bikes_occupied?.Values,    // There are no occupied bikes.
				string.Empty,
				() => DateTime.Now);

		/// <summary> Gets bikes occupied from copri server response. </summary>
		/// <param name="p_oBikesAvailable">Response to create bikes from.</param>
		/// <returns>New collection of occupied bikes.</returns>
		public static BikeCollection GetBikesOccupied(
			this BikesReservedOccupiedResponse bikesOccupiedResponse,
			string mail,
			Func<DateTime> dateTimeProvider)
		{
			return GetBikesAll(
				new BikesAvailableResponse()?.bikes?.Values,
				bikesOccupiedResponse?.bikes_occupied?.Values,
				mail,
				dateTimeProvider);
		}

		/// <summary> Gets bikes occupied from copri server response. </summary>
		/// <param name="bikesAvailable">Response to create bikes available from.</param>
		/// <param name="bikesOccupied">Response to create bikes occupied from.</param>
		/// <returns>New collection of occupied bikes.</returns>
		public static BikeCollection GetBikesAll(
			IEnumerable<BikeInfoAvailable> bikesAvailable,
			IEnumerable<BikeInfoReservedOrBooked> bikesOccupied,
			string mail,
			Func<DateTime> dateTimeProvider)
		{
			var bikesDictionary = new Dictionary<string, BikeInfo>();
			var duplicates = new Dictionary<string, BikeInfo>();

			// Get bikes from Copri/ file/ memory, ....
			if (bikesAvailable != null)
			{
				foreach (var bikeInfoResponse in bikesAvailable)
				{
					var bikeInfo = BikeInfoFactory.Create(bikeInfoResponse);
					if (bikeInfo == null)
					{
						// Response is not valid.
						continue;
					}

					if (bikesDictionary.ContainsKey(bikeInfo.Id))
					{
						// Duplicates are not allowed.
						Log.Error($"Duplicate bike with id {bikeInfo.Id} detected evaluating bikes available. Bike status is {bikeInfo.State.Value}.");

						if (!duplicates.ContainsKey(bikeInfo.Id))
						{
							duplicates.Add(bikeInfo.Id, bikeInfo);
						}

						continue;
					}

					bikesDictionary.Add(bikeInfo.Id, bikeInfo);
				}
			}

			// Get bikes from Copri/ file/ memory, ....
			if (bikesOccupied != null)
			{
				foreach (var bikeInfoResponse in bikesOccupied)
				{
					BikeInfo bikeInfo = BikeInfoFactory.Create(
						bikeInfoResponse,
						mail,
						dateTimeProvider);

					if (bikeInfo == null)
					{
						continue;
					}

					if (bikesDictionary.ContainsKey(bikeInfo.Id))
					{
						// Duplicates are not allowed.
						Log.Error($"Duplicate bike with id {bikeInfo.Id} detected evaluating bikes occupied. Bike status is {bikeInfo.State.Value}.");
						if (!duplicates.ContainsKey(bikeInfo.Id))
						{
							duplicates.Add(bikeInfo.Id, bikeInfo);
						}

						continue;
					}


					bikesDictionary.Add(bikeInfo.Id, bikeInfo);
				}
			}

			// Remove entries which are not unique.
			foreach (var l_oDuplicate in duplicates)
			{
				bikesDictionary.Remove(l_oDuplicate.Key);
			}

			return new BikeCollection(bikesDictionary);
		}
	}
}