gehgassi_app/gehGassiApp/gehGassiApp.Core/Interfaces/ICommunicationService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using gehGassi.Dto;
using gehGassi.Dto.Advertisements;
using gehGassi.Dto.Banners;
using gehGassi.Dto.Common;
using gehGassi.Dto.Dogs;
using gehGassi.Dto.DogWalkers;
using gehGassi.Dto.Favourites;
using gehGassi.Dto.Feedback;
using gehGassi.Dto.Listings;
using gehGassi.Dto.Messages;
using gehGassi.Dto.News;
using gehGassi.Dto.Payment;
using gehGassi.Dto.Pushnotifications;
using gehGassi.Dto.Ratings;
using gehGassi.Dto.Reporting;
using gehGassi.Dto.Walks;
using gehGassiApp.Core.Messaging;
using gehGassiApp.Domain.Advertisements;
using gehGassiApp.Domain.AppVersions;
using gehGassiApp.Domain.Authentication;
using gehGassiApp.Domain.Banners;
using gehGassiApp.Domain.Common;
using gehGassiApp.Domain.Dogs;
using gehGassiApp.Domain.Favourites;
using gehGassiApp.Domain.Feedback;
using gehGassiApp.Domain.Listings;
using gehGassiApp.Domain.Lookup;
using gehGassiApp.Domain.Messages;
using gehGassiApp.Domain.News;
using gehGassiApp.Domain.Payment;
using gehGassiApp.Domain.Pushnotifications;
using gehGassiApp.Domain.Subscriptions;
using gehGassiApp.Domain.Users;
using gehGassiApp.Domain.Vouchers;
using gehGassiApp.Domain.Walkers;
using gehGassiApp.Domain.Walks;
using Platform = gehGassiApp.Domain.Common.Platform;

namespace gehGassiApp.Core.Interfaces
{
    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Kommunikation mit dem Server ermöglicht
    /// </summary>
    public interface ICommunicationService
    {
        /// <summary>
        /// Prüft ob eine Verbindung zum Server besteht
        /// </summary>
        /// <returns>true wenn verbunden, false sonst</returns>
        Task<bool> IsConnected();

        #region Helper für DebugInfo

        bool GetIsOnline();
        bool GetHasInternet();
        DateTimeOffset? GetLastOnlineCheck();
        NetworkAccess GetCurrentNetworkAccess();

        #endregion

        #region Registrierung

        /// <summary>
        /// Prüfen ob ein Benutzername noch verfügbar ist und ob das Passwort ausreicht
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>true wenn alles passt, false sonst</returns>
        Task<CommunicationResult<bool>> RegisterCheckAvailableAsync(string userName, string password, CancellationToken token);

        /// <summary>
        /// Prüfen ob ein Passwort ausreicht
        /// </summary>
        /// <param name="password">Passwort</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>true wenn alles passt, false sonst</returns>
        Task<CommunicationResult<bool>> CheckPasswordAsync(string password, CancellationToken token);

        /// <summary>
        /// Registrieren eines App-Users
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="country">Land</param>
        /// <param name="token">CancellationToken</param>
        /// <param name="appUserType">AppUser-Typ</param>
        /// <param name="firstName">Vorname</param>
        /// <param name="lastName">Nachname</param>
        /// <param name="birthDate">Geburtsdatum</param>
        /// <param name="zip">PLZ</param>
        /// <param name="city">Ort</param>
        /// <param name="state">Bundesland</param>
        /// <param name="nationality">Nationalität</param>
        /// <param name="mainResidence">Land Hauptwohnsitz</param>
        /// <returns>true wenn alles passt, false sonst</returns>
        Task<CommunicationResult<bool>> RegisterAsync(string userName, string password, AppUserType appUserType, string firstName, string lastName, DateTimeOffset? birthDate, string zip, string city, string state, string country, string nationality, string mainResidence, CancellationToken token);

        /// <summary>
        /// Registrieren eines App-Users Extern
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="country">Land</param>
        /// <param name="token">CancellationToken</param>
        /// <param name="appUserType">AppUser-Typ</param>
        /// <param name="firstName">Vorname</param>
        /// <param name="lastName">Nachname</param>
        /// <param name="birthDate">Geburtsdatum</param>
        /// <param name="zip">PLZ</param>
        /// <param name="city">Ort</param>
        /// <param name="state">Bundesland</param>
        /// <param name="accessToken">Token des externen Providers</param>
        /// <param name="loginProvider">Login-Provider</param>
        /// <param name="nationality">Nationalität</param>
        /// <param name="mainResidence">Land Hauptwohnsitz</param>
        /// <returns>true wenn alles passt, false sonst</returns>
        Task<CommunicationResult<User>> RegisterExternalAsync(string userName, string password, AppUserType appUserType, string firstName, string lastName, DateTimeOffset? birthDate, string zip, string city, string state, string country, string nationality, string mainResidence, string accessToken, string loginProvider, CancellationToken token);


        #endregion

        #region Token / Login

        /// <summary>
        /// Anmelden eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<User>> LoginAsync(string userName, string password, CancellationToken token);

        /// <summary>
        /// Anmelden eines Benutzers mittels Acces-Token wegen external Provider
        /// </summary>
        /// <param name="accessToken">Access-Token</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<User>> LoginExternalAsync(string accessToken, CancellationToken token);

        /// <summary>
        /// Anmelden eines Benutzers mittels Apple Provider
        /// </summary>
        /// <param name="dto">Login-Daten von Apple</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<User>> LoginAppleAsync(LoginAppleDto dto, CancellationToken token);

        /// <summary>
        /// Abmelden eines Benutzers.
        /// Löscht alle Refreshtokens des Benutzers
        /// </summary>
        /// <param name="accessToken">Access-Token</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> LogoutAsync(string accessToken, CancellationToken token);

        /// <summary>
        /// Zurücksetzen des Passworts eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername / Email</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> ResetPasswordAsync(string userName, CancellationToken token);

        /// <summary>
        /// Senden der E-Mail Bestätigung für einen Benutzer
        /// </summary>
        /// <param name="userName">Benutzername / Email</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> ResendConfirmationAsync(string userName, CancellationToken token);

        /// <summary>
        /// Anmelden eines Benutzers mittels Refreshtoken
        /// </summary>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="refreshToken">Refreshtoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<TokenResponse>> RefreshTokenAsync(string accessToken, string refreshToken, CancellationToken token);

        /// <summary>
        /// Prüfen ob ein Benutzer ein Passwort hat
        /// </summary>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> HasPasswordAsync(string accessToken, CancellationToken token);

        /// <summary>
        /// Hinzufügen eines Passswortes zu einem Benutzer, wenn dieser keines hat
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort das hinzugefügt werden soll</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> AddPasswordAsync(string userName, string password, string accessToken, CancellationToken token);

        /// <summary>
        /// Ändern des Passwortes eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort das gesetzt werden soll</param>
        /// <param name="oldPassword">Bisheriges Passwort</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> ChangePasswordAsync(string userName, string password, string oldPassword, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen des Accounts eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="userId">Id des Benutzers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeleteAccountAsync(string userName, string userId, string accessToken, CancellationToken token);

        #endregion

        #region AppUser

        /// <summary>
        /// Holt den App-User für den aktuell angemeldeten Benutzer
        /// </summary>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppUser>> GetAppUserAsync(string accessToken, CancellationToken token);

        /// <summary>
        /// Holt den App-User für den aktuell angemeldeten Benutzer Sync!
        /// </summary>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppUser>> GetAppUserSyncAsync(DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren eines App-Users am Server
        /// </summary>
        /// <param name="appUserDto">App-User DTO</param>
        /// <param name="photoFile">Foto-Datei</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <param name="photoFileName">Dateiname Photo</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdateAppUserAsync(AppUserDto appUserDto, string photoFileName, byte[] photoFile, string accessToken, CancellationToken token);

        /// <summary>
        /// Setzen des AppUser Types am Server.
        /// Kann nur online erfolgen!
        /// </summary>
        /// <param name="setAppUserTypeDto">Dto für das Setzen des Typs</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> SetAppUserTypeAsync(SetAppUserTypeDto setAppUserTypeDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Setzen des AppUser Types am Server. Wenn hundebesitzer Walker wird
        /// Kann nur online erfolgen!
        /// </summary>
        /// <param name="setAppUserTypeDto">Dto für das Setzen des Typs</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppUser>> SetAppUserTypeAsync(SetAppUserTypeExDto setAppUserTypeDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Hinzufügen eines Payment Users am Server.
        /// </summary>
        /// <param name="addPaymentUserDto">DTO für das Hinzufügen des Payment-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppUser>> AddPaymentUserAsync(AddPaymentUserDto addPaymentUserDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Blockieren eines App-Users am Server
        /// </summary>
        /// <param name="blockDto">Dto für das Blockieren eines anderen App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> BlockAppUserAsync(BlockCreateDto blockDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Blockieren eines App-Users am Server aufheben
        /// </summary>
        /// <param name="unblockDto">Dto für das Aufheben der Blockierung eines anderen App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UnblockAppUserAsync(BlockRemoveDto unblockDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von blockierten App-Usern
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<AppUserBlockWithNames>>> GetBlockedAppUsersAsync(BlockedQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Melden eines App-Users
        /// </summary>
        /// <param name="reportDto">Dto für das Melden eines anderen App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> ReportAppUserAsync(AppUserReportDto reportDto, string accessToken, CancellationToken token);

        #endregion

        #region Walker Profile

        /// <summary>
        /// Holt den das Walker Profil für den aktuell angemeldeten Benutzer
        /// </summary>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<DogWalkerProfile>> GetWalkerProfileAsync(string accessToken, CancellationToken token);

        /// <summary>
        /// Holt das Walker Profil für den aktuell angemeldeten Benutzer Sync!
        /// </summary>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<DogWalkerProfile>> GetWalkerProfileSyncAsync(DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren eines Dogwalker Profils am Server
        /// </summary>
        /// <param name="walkerProfileDto">Profil DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdateWalkerProfileAsync(DogWalkerProfileDto walkerProfileDto, string accessToken, CancellationToken token);

        #endregion

        #region DogOwners

        /// <summary>
        /// Gibt Detailsinfos zu einem DogOwner zurück
        /// </summary>
        /// <param name="dogOwnerId">Id des DogOwners</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<DogOwnerInfo>> GetDogOwnerAsync(string dogOwnerId, string accessToken, CancellationToken token);

        #endregion

        #region DogWalkers

        /// <summary>
        /// Gibt Detailsinfos zu einem Dogwalker zurück
        /// </summary>
        /// <param name="dogWalkerId">Id des Dogwalkers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<DogWalkerInfo>> GetDogWalkerAsync(string dogWalkerId, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Dogwalkern vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<DogWalkerInfo>>> GetDogWalkersAsync(DogWalkerQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Dogwalkern vom Server. Als Lookup
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<DogWalkerLookup>>> GetDogWalkersLookupAsync(DogWalkerQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der Walkingtimes vom Server
        /// </summary>
        /// <param name="dogWalkerId">Id des DogWalkers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<WalkingTime>>> GetWalkingTimesForSyncAsync(string dogWalkerId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen einer WalkingTime am Server
        /// </summary>
        /// <param name="walkingTimeDto">WalkingTime</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<WalkingTime>>> CreateWalkingTimeAsync(WalkingTimeDto walkingTimeDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren einer WalkingTime am Server
        /// </summary>
        /// <param name="walkingTimeDto">WalkingTime DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdateWalkingTimeAsync(WalkingTimeDto walkingTimeDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen einer WalkingTime am Server
        /// </summary>
        /// <param name="walkingTimeDto">WalkingTime DTO</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeleteWalkingTimeAsync(WalkingTimeDto walkingTimeDto, string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt alle WalkingTimes eins Dogwalkers vom Server zurück
        /// </summary>
        /// <param name="dogWalkerId">ID des DogWalkers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<WalkingTime>>> GetAllWalkingTimesAsync(string dogWalkerId, string accessToken, CancellationToken token);

        #endregion

        #region News & NewsCategory

        /// <summary>
        /// Holen der News-Kategorien vom Server.
        /// </summary>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<NewsCategory>>> GetNewsCategoriesAsync(DateTimeOffset? lastUpdate, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von News vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<News>>> GetNewsAsync(NewsQueryDto query, string accessToken, CancellationToken token);

        #endregion

        #region Lookup

        /// <summary>
        /// Gibt eine Liste von Dog- Ownern und Walkern basierend auf einem Filter zurück
        /// </summary>
        /// <param name="filter">Filter</param>
        /// <param name="take">Anzahl max. Datensätze</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<AppUserLookup>>> LookupEntitiesAsync(string filter, int take, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine Liste von Dogwalkern mit Distanz zur aktuellen Position zurück
        /// </summary>
        /// <param name="ignoreId">Id die ignoriert werden soll falls der Benutzer DogOwner und DogWalker ist</param>
        /// <param name="lat">Breitengrad</param>
        /// <param name="lng">Längengrad</param>
        /// <param name="take">Anzahl Walker gewünscht</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<DogWalkerLookup>>> LookupDogWalkersAsync(string ignoreId, double lat, double lng, int take, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt Detailsinfos zu einem Dogwalker zurück
        /// </summary>
        /// <param name="dogWalkerId">Id des Dogwalkers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<DogWalkerInfo>> LookupDogWalkerAsync(string dogWalkerId, string accessToken, CancellationToken token);

        #endregion

        #region Messages & Conversations

        /// <summary>
        /// Holt eine Liste der Konversationen eines Benutzers
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Liste von Konversationen</returns>
        Task<CommunicationResult<List<Conversation>>> GetConversationsAsync(string senderId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Holt eine Liste der Konversationen eines Benutzers mit Filter am Server.
        /// Geblockte oder Gesperrte Benutzer werden nicht zurückgegeben.
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="filter">Filter</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Liste von Konversationen</returns>
        Task<CommunicationResult<List<Conversation>>> GetConversationsWithFilterAsync(string senderId, string filter, string accessToken, CancellationToken token);

        /// <summary>
        /// Holt eine Konversationen eines Benutzers mit einem Ziel
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="receipientId">Id des Empfängers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Liste von Konversationen</returns>
        Task<CommunicationResult<Conversation>> GetConversationByReceipientAsync(string senderId, string receipientId, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen einer Konversation am Server
        /// </summary>
        /// <param name="conversationId">Gewünschte Id der Konversation</param>
        /// <param name="senderId">Id des Senders</param>
        /// <param name="receiverId">Id des Empfängers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Conversation>>> CreateConversationAsync(string conversationId, string senderId, string receiverId, string accessToken, CancellationToken token);

        /// <summary>
        /// Holt eine Liste der offenen Nachrichten eines Benutzers
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Liste von Konversationen</returns>
        Task<CommunicationResult<List<Message>>> GetMessagesAsync(string senderId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Holt eine Liste der offenen Nachrichten eines Benutzers für eine Konversation
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="conversationId">Id der Konversation</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Liste von Konversationen</returns>
        Task<CommunicationResult<List<Message>>> GetMessagesAsync(string senderId, string conversationId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Bestätigen des erfolgreichen Erhalts von Nachrichten für einen Benutzer
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> ConfirmMessagesAsync(string senderId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Bestätigen des erfolgreichen Erhalts von Nachrichten für einen Benutzer für eine Konversation
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="conversationId">Id der Konversation</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> ConfirmMessagesAsync(string senderId, string conversationId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen einer Nachricht am Server
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="receiverId">Id des Benutzers Empfänger</param>
        /// <param name="message">Nachricht</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Message>>> AddMessageAsync(string senderId, string receiverId, Message message, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der Systemnachrichten vom Server für Sync
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<SystemMessage>>> GetSystemMessagesForSyncAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Bestätigen des erfolgreichen Erhalts von SystemNachrichten für einen Benutzer
        /// </summary>
        /// <param name="senderId">Id des Benutzers (DogOwner | DogWalker)</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> ConfirmSystemMessagesAsync(string senderId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Entfernen von Systemnachrichten vom Server für einen AppUser und eine bestimmte Kombination aus Key und Table
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <param name="key">Key</param>
        /// <param name="table">Table</param>
        /// <param name="created">Alter als dieses Datum</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> RemoveSystemMessagesAsync(string appUserId, AppUserType appUserType, string key, string table, DateTimeOffset? created, string accessToken, CancellationToken token);

        #endregion

        #region Listings

        /// <summary>
        /// Holen der Branchen und Listungen Übersicht
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<BranchWithListings>>> GetListingsOverviewAsync(QueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Listungen nahe dem Benutzer vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<Listing>>> GetListingsNearAsync(QueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine laufende Listung zurück
        /// </summary>
        /// <param name="id">Id der Listung</param>
        /// <param name="language">gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Listing>> GetListingRunningAsync(string id, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Listungen je Branche mit Geo-Einschränkungen
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<Listing>>> GetListingsByBranchAsync(ListingQueryDto query, string accessToken, CancellationToken token);

        #endregion

        #region Banners

        /// <summary>
        /// Abfragen eines zufälligen Banners für eine Platzierung
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Banner>> GetBannerForLocationAsync(BannerQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Hinzufügen von Klicks zu einem Banner
        /// </summary>
        /// <param name="dtoModel">Model für einen Klick für Banner</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>true wenn der Banner noch gültig ist, false sonst</returns>
        Task<CommunicationResult<bool>> AddClicksAsync(BannerClickDto dtoModel, string accessToken, CancellationToken token);

        /// <summary>
        /// Hinzufügen von Views zu einem Banner
        /// </summary>
        /// <param name="dtoModel">Model für einen View für Banner</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>true wenn der Banner noch gültig ist, false sonst</returns>
        Task<CommunicationResult<bool>> AddViewsAsync(BannerViewDto dtoModel, string accessToken, CancellationToken token);

        #endregion

        #region Advertisements

        /// <summary>
        /// Holen der Liste der Werbungs-Kategorien welche online sind
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<AdvertisementCategory>>> GetAdvertisementCategoriesOnlineAsync(string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von ablaufenden Werbungen mit Geo-Einschränkungen
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<Advertisement>>> GetAdvertisementsNearEndAsync(QueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine laufende Werbung zurück
        /// </summary>
        /// <param name="id">Id der Werbung</param>
        /// <param name="language">gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Advertisement>> GetAdvertisementRunningAsync(string id, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Werbungen je Kategorie mit Geo-Einschränkungen
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<Advertisement>>> GetAdvertisementsByCategoryAsync(AdvertisementQueryDto query, string accessToken, CancellationToken token);

        #endregion

        #region Dogs & Dogsraces

        /// <summary>
        /// Holen der Hunderassen vom Server.
        /// </summary>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<DogRace>>> GetDogRacesAsync(DateTimeOffset? lastUpdate, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen einer Hunderassen vom Server.
        /// </summary>
        /// <param name="id">Id der Hunderasse</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<DogRace>> GetDogRaceAsync(string id, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der Hunde vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<Dog>>> GetDogsAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der Hunde vom Server als MinInfo
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<DogMinInfo>>> GetDogsMinAsync(string appUserId, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen eines Hundes vom Server
        /// </summary>
        /// <param name="dogId">Id des Hundes</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Dog>> GetDogAsync(string dogId, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen eines Hundes am Server
        /// </summary>
        /// <param name="dogDto">Hund DTO</param>
        /// <param name="photoFile">Foto-Datei</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <param name="photoFileName">Dateiname Photo</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Dog>>> AddDogAsync(DogDto dogDto, string photoFileName, byte[] photoFile, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren eines Hundes am Server
        /// </summary>
        /// <param name="dogDto">Hund DTO</param>
        /// <param name="photoFile">Foto-Datei</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <param name="photoFileName">Dateiname Photo</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdateDogAsync(DogDto dogDto, string photoFileName, byte[] photoFile, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen eines Hundes am Server
        /// </summary>
        /// <param name="dogDto">Hund DTO</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeleteDogAsync(DogDto dogDto, string appUserId, string accessToken, CancellationToken token);

        #endregion

        #region Walks

        /// <summary>
        /// Gibt die Anzahl öffentlicher Anfragen für einen Benutzer zurück
        /// </summary>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<int>> CountPublicWalkRequestsAsync(string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der öffentlichen Anfragen vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<PublicWalkRequest>>> GetPublicWalkRequestsForSyncAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der öffentlichen Anfragen vom Server für die letzten
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="take">Anzahl Datensätze</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<PublicWalkRequestWithNames>>> GetPublicWalkRequestsLatestAsync(string appUserId, string language, int take, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von öffentlichen Anfragen vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<PublicWalkRequestWithNames>>> GetPublicWalkRequestsAsync(PublicWalkRequestQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von öffentlichen Anfragen vom Server - erweitert
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<PublicWalkRequestWithNames>>> GetPublicWalkRequestsExAsync(PublicWalkRequestQueryExDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von öffentlichen Anfragen vom Server mit einem Antwortstatus für einen DogWalker
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<PublicWalkRequestWithNamesAndResponseStatus>>> GetPublicWalkRequestsWithResponseStatusAsync(PublicWalkRequestAndResponseStatusQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von öffentlichen Anfragen vom Server mit einem Antwortstatus für einen DogWalker mit erweiterten Suchparametern
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<PublicWalkRequestWithNamesAndResponseStatus>>> GetPublicWalkRequestsWithResponseStatusExAsync(PublicWalkRequestAndResponseStatusQueryExDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen einer öffntlichen Anfrage vom Server.
        /// </summary>
        /// <param name="id">Id der Anfrage</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<PublicWalkRequestWithNames>> GetPublicWalkRequestWithNamesAsync(string id, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="requestDto">Öffentliche Anfrage</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<PublicWalkRequest>>> CreatePublicWalkRequestAsync(PublicWalkRequestCreateDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdatePublicWalkRequestAsync(PublicWalkRequestDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeletePublicWalkRequestAsync(PublicWalkRequestDto requestDto, string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Auswählen eines Angebotes zu einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Walk>> AcceptPublicWalkRequestAsync(PublicWalkRequestAcceptDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Stornieren einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> CancelPublicWalkRequestAsync(PublicWalkRequestCancelDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der Antworten zu öffentlichen Anfragen vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<PublicWalkResponse>>> GetPublicWalkResponsesForSyncAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen einer Antworten zu öffentlichen Anfragen vom Server
        /// </summary>
        /// <param name="publicWalkResponseId">Id der Antwort zur öffentlichen Anfrage</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<PublicWalkResponse>> GetPublicWalkResponseAsync(string publicWalkResponseId, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen einer Antworten zu öffentlichen Anfragen vom Server
        /// </summary>
        /// <param name="publicWalkResponseId">Id der Antwort zur öffentlichen Anfrage</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<PublicWalkResponseWithNames>> GetPublicWalkResponseWithNamesAsync(string publicWalkResponseId, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen einer Antworten zu öffentlichen Anfragen vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="publicWalkRequestId">Id der öffentlichen Anfrage</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<PublicWalkResponse>> GetPublicWalkResponseForWalkerAsync(string appUserId, string publicWalkRequestId, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen einer Antwort zu einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="responseDto">Antwort zur Öffentliche Anfrage</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<PublicWalkResponse>>> CreatePublicWalkResponseAsync(PublicWalkResponseDto responseDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren einer Antwort zu einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="responseDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdatePublicWalkResponseAsync(PublicWalkResponseDto responseDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen einer Antwort zu einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="responseDto">Anfrage DTO</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeletePublicWalkResponseAsync(PublicWalkResponseDto responseDto, string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Antworten zu einer öffentlichen Anfrage vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<ListCommunicationResult<List<PublicWalkResponseWithNames>>> GetPublicWalkresponsesAsync(PublicWalkResponseQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Ablehnen eines Angebotes zu einer öffentlichen Anfrage am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeclinePublicWalkResponseAsync(PublicWalkResponseDeclineDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Bearbeiten eines bereits gestellten Angebotes für eine offene Anfrage
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> EditPublicWalkResponseAsync(PublicWalkResponseEditDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Stornieren eines bereits gestellten Angebotes für eine offene Anfrage
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> CancelPublicWalkResponseAsync(PublicWalkResponseCancelDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der Walsk vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<Walk>>> GetWalksForSyncAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen eines Walks Anfrage am Server
        /// </summary>
        /// <param name="walkDto">Walk</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Walk>>> CreateWalkAsync(WalkDto walkDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren eines Walks am Server
        /// </summary>
        /// <param name="walkDto">Walk DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdateWalkAsync(WalkDto walkDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen eines Walks am Server
        /// </summary>
        /// <param name="walkDto">Walk DTO</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeleteWalkAsync(WalkDto walkDto, string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Walks mit Namen vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<WalkWithNames>>> GetWalksWithNamesAsync(WalksQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine Liste der nächsten Walks, laufende, nicht abgeschlossene, nicht bezahlte usw. für einen Hundebesitzer zurück.
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="date">Datum ab dem gesucht</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<WalkWithNames>>> GetNextWalksOwnerAsync(string appUserId, DateTimeOffset date, string language, int take, int skip, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine Liste der nächsten Walks, laufende, nicht abgeschlossene, nicht bezahlte usw. für einen Walker zurück.
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="date">Datum ab dem gesucht</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<WalkWithNames>>> GetNextWalksWalkerAsync(string appUserId, DateTimeOffset date, string language, int take, int skip, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Walks mit Namen vom Server.
        /// Sondersituation: Walker bekommen keine Walks unter dem Status Authorized zurück
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<WalkWithNames>>> GetWalksWithNamesWalkerAsync(WalksQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen eines Walks mit Namen vom Server
        /// </summary>
        /// <param name="walkId">ID des Walks</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<WalkWithNames>> GetWalkWithNamesAsync(string walkId, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt einen Walk zurück, welcher einer öffentlichen Anfrage zugeordnet ist
        /// </summary>
        /// <param name="publicWalkRequestId">ID der öffentlichen Anfrage</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Walk>> GetWalkByPublicRequestAsync(string publicWalkRequestId, string accessToken, CancellationToken token);

        /// <summary>
        /// Stornieren eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> CancelWalkAsync(WalkCancelDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Starten eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> StartWalkAsync(WalkStartDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// abschließen eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> CompleteWalkAsync(WalkCompleteDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Bestätigen eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Walk>> ConfirmWalkAsync(WalkConfirmDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Bestätigen eines Walks am Server mit Rating
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Walk>> ConfirmWalkWithRatingAsync(WalkConfirmWithRatingDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Setzen des Zahlungsstatus eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> SetWalkPaymentStatusAsync(WalkPaymentStatusDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Prüfen ob ein Walk für einen Zeitraum gebucht werden kann
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> IsWalkPossibleAsync(WalkPossibleDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen eines Walks wenn DIREKT! buchen möglich ist.
        /// Wird online versucht und erst dann lokal gespeichert
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Walk>>> CreateWalkDirectAsync(WalkCreateDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen eines Walks als Anfrage
        /// Wird online versucht und erst dann lokal gespeichert
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Walk>>> CreateWalkRequestAsync(WalkCreateDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Akzeptieren eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> AcceptWalkAsync(WalkAcceptDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Ablehnen eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeclineWalkAsync(WalkDeclineDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Reklamieren eines Walks am Server
        /// </summary>
        /// <param name="requestDto">Anfrage DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Walk>> ComplainWalkAsync(WalkComplaintCreateDto requestDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen einer Reklamation zu einem Walk
        /// </summary>
        /// <param name="walkId">ID des Walks</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<WalkComplaint>> GetWalkComplaintAsync(string walkId, string accessToken, CancellationToken token);

        #endregion

        #region Ratings

        /// <summary>
        /// Holen der Ratings vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<Rating>>> GetRatingsForSyncAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt ein Rating basierend auf Abfragekriterien zurück
        /// </summary>
        /// <param name="ratingCheckDto">Rating check DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Rating>> GetRatingExAsync(RatingCheckQueryDto ratingCheckDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt ein Rating basierend auf der ID zurück
        /// </summary>
        /// <param name="ratingId">Id des Ratings</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<RatingWithNames>> GetRatingAsync(string ratingId, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen eines Ratings am Server
        /// </summary>
        /// <param name="ratingDto">Rating</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Rating>>> CreateRatingAsync(RatingDto ratingDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren eines Ratings am Server
        /// </summary>
        /// <param name="ratingDto">Rating DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdateRatingAsync(RatingDto ratingDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen eines Ratings am Server
        /// </summary>
        /// <param name="ratingDto">Rating DTO</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeleteRatingAsync(RatingDto ratingDto, string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Prüfen ob bereits ein Rating vorhanden ist
        /// </summary>
        /// <param name="ratingCheckDto">Rating check DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> HasRatedAsync(RatingCheckQueryDto ratingCheckDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Prüfen ob ein Rating vorgenommen werden kann
        /// </summary>
        /// <param name="ratingCheckDto">Rating check DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> CanRateAsync(RatingCheckQueryDto ratingCheckDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Ratings mit Namen vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<RatingWithNames>>> GetRatingsWithNamesAsync(RatingsQueryDto query, string accessToken, CancellationToken token);

        #endregion

        #region Feedback

        /// <summary>
        /// Anlegen eines Feedbacks am Server
        /// </summary>
        /// <param name="dto">Feedback</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<AppFeedback>>> CreateFeedbackAsync(AppFeedbackCreateDto dto, string accessToken, CancellationToken token);

        #endregion

        #region Favourites

        /// <summary>
        /// Holen der Favoriten vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<Favourite>>> GetFavouritesForSyncAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen eines Favoriten am Server
        /// </summary>
        /// <param name="favouriteDto">Favorit</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<Favourite>>> CreateFavouriteAsync(FavouriteDto favouriteDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Aktualisieren eines Favoriten am Server
        /// </summary>
        /// <param name="favouriteDto">Favorit DTO</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> UpdateFavouriteAsync(FavouriteDto favouriteDto, string accessToken, CancellationToken token);

        /// <summary>
        /// Löschen eines Favoriten am Server
        /// </summary>
        /// <param name="favouriteDto">Favorit DTO</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> DeleteFavouriteAsync(FavouriteDto favouriteDto, string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der Favoriten für einen Benutzer. Wird mit einem Objekt-Typen verwendet
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<FavouriteListItem>>> GetFavouritesListAsync(FavouriteListQueryDto query, string accessToken, CancellationToken token);

		#endregion

		#region Pushnotifications

		/// <summary>
		/// Registrieren / Aktualisieren eines Gerätes für Pushnotifications
		/// </summary>
		/// <param name="deviceInstallation">Geräte-Informationen</param>
		/// <param name="accessToken">Aktuelles Accesstoken</param>
		/// <param name="token">CancellationToken</param>
		/// <returns>CommunicationResult</returns>
		Task<CommunicationResult<bool>> RegisterPushnotificationsAsync(DeviceInstallationDto deviceInstallation, string accessToken, CancellationToken token);

		/// <summary>
		/// Deregistrieren eines Gerätes für Pushnotifications
		/// </summary>
		/// <param name="installationId">Id der Installation</param>
		/// <param name="accessToken">Aktuelles Accesstoken</param>
		/// <param name="token">CancellationToken</param>
		/// <returns>CommunicationResult</returns>
		Task<CommunicationResult<bool>> UnregisterPushnotificationsAsync(string installationId, string accessToken, CancellationToken token);

        #endregion

        #region Wallets

        /// <summary>
        /// Holen der Wallets eines AppUsers vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<Wallet>>> GetWalletsAsync(string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt den Saldo eines Wallets zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="walletType">Typ des Wallets</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<long>> GetWalletBalanceAsync(string appUserId, WalletType walletType, string accessToken, CancellationToken token);

        #endregion

        #region Bankkonten

        /// <summary>
        /// Holt ein Bankkonto für einen App-User vom Server
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<BankAccount>> GetBankAccountsAsync(string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Anlegen oder Bearbeiten eines Bankkontos
        /// </summary>
        /// <param name="bankAccount">Bankkonto</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult mit einem AppUser der die entsprechende BankId gesetzt hat</returns>
        Task<CommunicationResult<AppUser>> CreateOrUpdateBankAccountAsync(BankAccountDto bankAccount, string accessToken, CancellationToken token);

        #endregion

        #region Transaktionsgebühren

        /// <summary>
        /// Holen der Transaktionsgebühren vom Server.
        /// </summary>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<TransactionFee>>> GetTransactionFeesAsync(DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        #endregion

        #region Payment

        /// <summary>
        /// Authorisierung der Bezahlung eines Walks mit dem Guthaben eines Wallets
        /// Das Geld wird vom Guthabenkonto auf das Transaktions-Konto gelegt
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="ammount">Zu zahlender Bertrag</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Walk>> AuthorizeWalkWithCreditAsync(string appUserId, string walkId, decimal ammount, string accessToken, CancellationToken token);

        /// <summary>
        /// Authorisierung der Bezahlung eines Walks komplett mit einem Gutschein
        /// </summary>
        /// <param name="voucherId">Id des Gutscheins</param>
        /// <param name="voucherCode">Code des Gutscheins</param>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="ammount">Zu zahlender Bertrag</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Walk>> AuthorizeWalkWithVoucherAsync(string voucherId, string voucherCode, string appUserId, string walkId, decimal ammount, string accessToken, CancellationToken token);

        /// <summary>
        /// Einzahlen einer Summe auf das Transaktions-Konto eines App-Users mit Bezug auf einen Walk.
        /// Es können gebühren sofort auf das Transaktions-Konto des Mandanten abgeführt werden
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="ammount">Zu zahlender Bertrag</param>
        /// <param name="fees">Anfallende Gebühren</param>
        /// <param name="fromCredit">Betrag der zusätzlich vom Guthabenkonto bezahlt werden muss</param>
        /// <param name="payInType">Typ der Einzahlung</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult mit dem ReturnUrl, wenn erfolgreich</returns>
        Task<CommunicationResult<string>> PayInAsync(string appUserId, string walkId, decimal ammount, decimal fees, decimal fromCredit, PayInType payInType, string accessToken, CancellationToken token);

        #endregion

        #region KYC

        /// <summary>
        /// Holen der letzten KYC-Dokumente eines App-Users
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult mit dem aktuell gültigen KYC-Dokument oder null, wenn keines vorhanden</returns>
        Task<CommunicationResult<IdentityDocument>> GetLatestKycDocumentAsync(string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// KYC-Dokument für einen App-User erstellen mit einer Seite
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="source">Dokument-Quelle</param>
        /// <param name="fileOneName">Dateiname</param>
        /// <param name="fileOne">Datei als byte-Array</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult mit dem aktuell erstellten KYC-Dokument</returns>
        Task<CommunicationResult<IdentityDocument>> CreateKycDocumentAsync(string appUserId, IdentityDocumentSource source, string fileOneName, byte[] fileOne, string accessToken, CancellationToken token);

        /// <summary>
        /// KYC-Dokument für einen App-User erstellen mit zwei Seiten
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="source">Dokument-Quelle</param>
        /// <param name="fileOneName">Dateiname Datei 1</param>
        /// <param name="fileOne">Datei 1 als byte-Array</param>
        /// <param name="fileTwoName">Dateiname Datei 2</param>
        /// <param name="fileTwo">Datei 2 als byte-Array</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult mit dem aktuell erstellten KYC-Dokument</returns>
        Task<CommunicationResult<IdentityDocument>> CreateKycDocumentAsync(string appUserId, IdentityDocumentSource source, string fileOneName, byte[] fileOne, string fileTwoName, byte[] fileTwo, string accessToken, CancellationToken token);

        #endregion

        #region Payouts

        /// <summary>
        /// Holen der Auszahlungen vom Server
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Wann wurden das letzte mal Daten erfolgreich geholt? Wenn null, dann alle Daten</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<Payout>>> GetPayoutsForSyncAsync(string appUserId, DateTimeOffset? lastUpdate, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen von Auszahlungen vom Server.
        /// </summary>
        /// <param name="query">Abfrageobjekt</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>ListCommunicationResult</returns>
        Task<ListCommunicationResult<List<Payout>>> GetPayoutsAsync(PayoutQueryDto query, string accessToken, CancellationToken token);

        /// <summary>
        /// Erstellen einer Auszahlung
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="ammount">Betrag der ausgezahlt werden soll</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Payout>> CreatePayoutAsync(string appUserId, decimal ammount, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine Auszahlung eines App-Users zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="payoutId">Id der Auszahlung</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<Payout>> GetPayoutAsync(string appUserId, string payoutId, string accessToken, CancellationToken token);

        #endregion

        #region AppVersion

        /// <summary>
        /// Holen der aktuellen Version am Server für die gewählte Plattform
        /// </summary>
        /// <param name="platform">Plattform</param>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppVersionCheck>> CheckCurrentAppVersionAsync(PlatformDto platform, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Holen der aktuellen Version am Server für die gewählte Plattform
        /// </summary>
        /// <param name="platform">Plattform</param>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppVersion>> GetCurrentAppVersionAsync(PlatformDto platform, string language, string accessToken, CancellationToken token);

        #endregion

        #region Vouchers - Gutscheine

        /// <summary>
        /// Validieren eines Gutschein-Codes für einen AppUser
        /// </summary>
        /// <param name="voucherCode">Gutscheincode</param>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CheckVoucherCodeResult>> CheckVoucherCodeAsync(string voucherCode, string appUserId, string accessToken, CancellationToken token);

        /// <summary>
        /// Versucht einen Gutscheincode mit Hilfe eines QR-Codes zu holen
        /// </summary>
        /// <param name="qrCode">QR-Code in Text</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<string>> GetVoucherCodeByQrCode(string qrCode, string accessToken, CancellationToken token);

        /// <summary>
        /// Versucht einen Gutschein zu reservieren
        /// </summary>
        /// <param name="voucherId">Id des Gutscheins</param>
        /// <param name="code">Code des Gutscheins</param>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="ammount">Betrag - kann kleiner Gutscheinwert sein</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<ReserveVoucherResult>> ReserveVoucherAsync(string voucherId, string code, string appUserId, string walkId, decimal ammount, string accessToken, CancellationToken token);

        /// <summary>
        /// Stornieren eines Gutscheins
        /// </summary>
        /// <param name="voucherId">Id des Gutscheins</param>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<bool>> CancelVoucherAsync(string voucherId, string appUserId, string walkId, string accessToken, CancellationToken token);

        #endregion

        #region Abos - Subscriptions

        /// <summary>
        /// Gibt eine Liste von verfügbaren Abos zurück
        /// </summary>
        /// <param name="appMode">AppMode - Hundebesitzer oder Walker</param>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<Subscription>>> GetSubscriptionsAsync(AppMode appMode, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine Liste von gebuchten Abos zurück
        /// </summary>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<AppUserSubscription>>> GetMySubscriptionsAsync(string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Gibt eine Liste von gebuchten und aktiven Abos zurück
        /// </summary>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<List<AppUserSubscription>>> GetMyActiveSubscriptionsAsync(string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Erstellen einer Abo-Buchung
        /// </summary>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="subscriptionId">Id des Abos</param>
        /// <param name="language">Sprache</param>
        /// <param name="inAppBillingPurchase">InAppBillingPurchase serialisiert als JSON</param>
        /// <param name="expirationDateToSet">Optional: Ablaufdatum das gesetzt werden soll</param>
        /// <param name="platform">Plattform auf der das Abo erstellt wird</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<CreateResponse<AppUserSubscription>>> CreateSubscriptionAsync(string appUserId, string subscriptionId, string language, string inAppBillingPurchase, DateTime? expirationDateToSet, Platform platform, string accessToken, CancellationToken token);

        /// <summary>
        /// Wechseln eines Abos in der Gruppe für eine Abo-Buchung
        /// </summary>
        /// <param name="bookingId">Id der Abo-Buchung</param>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="subscriptionId">Id des Abos auf das gechselt werden soll</param>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppUserSubscription>> SwitchSubscriptionAsync(long bookingId, string appUserId, string subscriptionId, string language, string accessToken, CancellationToken token);

        /// <summary>
        /// Stornieren einer Abo-Buchung
        /// </summary>
        /// <param name="bookingId">Abo-Buchungs ID</param>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="language">Sprache</param>
        /// <param name="platform">Plattform auf der das Abo erstellt wurde</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppUserSubscription>> CancelSubscriptionAsync(long bookingId, string appUserId, string language, Platform platform, string accessToken, CancellationToken token);

        /// <summary>
        /// Verlängern einer Abo-Buchung
        /// </summary>
        /// <param name="bookingId">Abo-Buchungs ID</param>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="language">Sprache</param>
        /// <param name="platform">Plattform auf der das Abo erstellt wurde</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        Task<CommunicationResult<AppUserSubscription>> RenewSubscriptionAsync(long bookingId, string appUserId, string language, Platform platform, string accessToken, CancellationToken token);

        #endregion
    }

    /// <summary>
    /// Ergebnis einer Kommunikation mit dem Server
    /// </summary>
    /// <typeparam name="T">Typ des Rückgabewertes</typeparam>
    public class CommunicationResult<T>
    {
        /// <summary>
        /// Erfolgreich?
        /// </summary>
        public bool Success { get; set; }

        /// <summary>
        /// Wenn nicht erfolgreich, Fehlermeldung
        /// </summary>
        public string ErrorMessage { get; set; }

        /// <summary>
        /// Der original Fehlercode, falls basierend darauf noch Aktionen folgen müssen
        /// </summary>
        public CommunicationErrors ErrorCode { get; set; }

        /// <summary>
        /// Wert wenn erfolgreich
        /// </summary>
        public T Value { get; set; }

        public CommunicationResult()
        {
            Success = false;
            ErrorMessage = string.Empty;
            ErrorCode = CommunicationErrors.None;
        }
    }

    /// <summary>
    /// Ergebnis einer Kommunikation mit dem Server für Listen.
    /// Beinhaltet zusätzliche Infos für das Paging
    /// </summary>
    /// <typeparam name="T">Typ des Rückgabewertes</typeparam>
    public class ListCommunicationResult<T> : CommunicationResult<T>
    {
        /// <summary>
        /// Gesamt verfügbare Datensätze
        /// </summary>
        public int Total { get; set; }

        /// <summary>
        /// Effektiv genommen - kann gegenüber Anfrage geändert werden, wenn weniger Datensätze da sind
        /// </summary>
        public int Take { get; set; }

        /// <summary>
        /// Effektiv ausgelassen - kann gegenüber Abfrage verändert werden, wenn weniger Datensätze
        /// </summary>
        public int Skip { get; set; }

        public ListCommunicationResult()
        {
            Total = 0;
            Skip = -1;
            Take = -1;
        }
    }
}