using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Fido2NetLib;
using gehGassi.Domain.Advertisements;
using gehGassi.Domain.Coins;
using gehGassi.Domain.Common;
using gehGassi.Domain.Customers;
using gehGassi.Domain.Devices;
using gehGassi.Domain.Dogs;
using gehGassi.Domain.Favourites;
using gehGassi.Domain.Feedback;
using gehGassi.Domain.Messages;
using gehGassi.Domain.News;
using gehGassi.Domain.Pages;
using gehGassi.Domain.Payment;
using gehGassi.Domain.Ratings;
using gehGassi.Domain.Reporting;
using gehGassi.Domain.Shop;
using gehGassi.Domain.Subscriptions;
using gehGassi.Domain.Users;
using gehGassi.Domain.Vouchers;
using gehGassi.Domain.Walks;
using gehGassi.Dto.Common;
using gehGassi.Dto.DogWalkers;
using NetTopologySuite.Geometries;

namespace gehGassi.Core.Interfaces
{
    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Benutzern realisiert
    /// </summary>
    public interface IUserService : IService<ApplicationUser>
    {
        /// <summary>
        /// Prüft ob ein Benutzername noch verfügbar ist.
        /// </summary>
        /// <param name="userName">Zu prüfender Benutzername</param>
        /// <param name="id">Id die ignoriert werden soll</param>
        /// <returns>true wenn verfügbar, false sonst</returns>
        Task<bool> IsUsernameAvailableAsync(string userName, string id = "");

        /// <summary>
        /// Gibt einen Benutzer anhand des Benutzernamens zurück
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <returns>ApplicationUser oder null, wenn nicht gefunden</returns>
        Task<ApplicationUser> GetByUsernameAsync(string userName);

        /// <summary>
        /// Gibt eine gefilterte Liste von Benutzer zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Benutzer</returns>
        IQueryable<ApplicationUser> Filter(string filter);

        /// <summary>
        /// Erstellen eines Benutzers
        /// </summary>
        /// <returns>Benutzer</returns>
        ApplicationUser Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Benutzern mit Namen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Benutzer</returns>
        IQueryable<ApplicationUserWithNames> FilterWithNames(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Benutzern mit Namen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="customerId">Id des Kunden</param>
        /// <returns>List betroffener Benutzer</returns>
        IQueryable<ApplicationUserWithNames> FilterWithNamesCustomer(string filter, long customerId);

        /// <summary>
        /// Zurücksetzen des Kunden auf null
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <returns>Task</returns>
        Task ResetCustomerAsync(long customerId);

        /// <summary>
        /// Zurücksetzen des App-Users auf null
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>Task</returns>
        Task ResetAppUserAsync(string appUserId);

        /// <summary>
        /// Gibt einen Benutzer anhand der App-UserId zurück
        /// </summary>
        /// <param name="appUserId">App-UserId</param>
        /// <returns>ApplicationUser oder null, wenn nicht gefunden</returns>
        Task<ApplicationUser> GetByAppUserAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Fido-Credentials realisiert
    /// </summary>
    public interface IFidoService : IService<FidoStoredCredential>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Fido-Credentials zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Fido-Credentials</returns>
        IQueryable<FidoStoredCredential> Filter(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Fido-Credentials für einen Benutzer zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="username">Benutzername</param>
        /// <returns>List betroffener Fido-Credentials</returns>
        IQueryable<FidoStoredCredential> Filter(string filter, string username);

        /// <summary>
        /// Erstellen eines Fido-Credentials
        /// </summary>
        /// <returns>Fido-Credential</returns>
        FidoStoredCredential Create();

        /// <summary>
        /// Gibt alle Credentials für einen Benutzer zurück
        /// </summary>
        /// <param name="username">Benutzername</param>
        /// <returns>Liste Credentials</returns>
        Task<List<FidoStoredCredential>> GetCredentialsAsync(string username);

        /// <summary>
        /// Gibt eine Liste aller Benutzer zurück die über eine CredentialId verfügen
        /// </summary>
        /// <param name="credentialId">CredentialId</param>
        /// <returns>Liste Fido2 User</returns>
        Task<List<Fido2User>> GetUsersByCredentialIdAsync(byte[] credentialId);

        /// <summary>
        /// Gibt zurück ob ein Benutzer über Fido credentials verfügt
        /// </summary>
        /// <param name="username">Benutzername</param>
        /// <returns>true wenn ja, false sonst</returns>
        Task<bool> HasFidoCredentialsAsync(string username);

        /// <summary>
        /// Gibt ein Credential zurück
        /// </summary>
        /// <param name="id">CredentialId</param>
        /// <returns>FidoStoredCredential</returns>
        Task<FidoStoredCredential> GetByIdAsync(byte[] id);

        /// <summary>
        /// Gibt eine Liste von Credentials anhand des userHandles zurück
        /// </summary>
        /// <param name="userHandle">Userhandle</param>
        /// <returns>Liste Credentials</returns>
        Task<List<FidoStoredCredential>> GetCredentialsByUserHandleAsync(byte[] userHandle);

        /// <summary>
        /// Aktualisieren des Counters
        /// </summary>
        /// <param name="credentialId"></param>
        /// <param name="counter"></param>
        /// <returns>Task</returns>
        Task UpdateCounterAsync(byte[] credentialId, uint counter);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der EU-UID-Nummern auf deren Gültigkeit prüft
    /// </summary>
    public interface IVatValidationService
    {
        /// <summary>
        /// Prüft eine UID-Nummer auf deren Gültigkeit
        /// </summary>
        /// <param name="vat">UID-Nummer</param>
        /// <param name="countryIso2">ISO-2 Code des Landes</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> IsValidAsync(string vat, string countryIso2);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Audits realisiert
    /// </summary>
    public interface IAuditService : IService<Audit>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von audits zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        IQueryable<Audit> Filter(string filter);

        /// <summary>
        /// Gibt eine Liste von Audits zurück
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <returns>Liste von audits</returns>
        Task<List<Audit>> GetListAsync(string key, string table);

        /// <summary>
        /// Gibt eine Liste von Audits zurück
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <param name="action">
        /// Durchgeführte Aktion</param>
        /// <returns>Liste von audits</returns>
        Task<List<Audit>> GetListAsync(string key, string table, AuditAction action);

        /// <summary>
        /// Gibt einen Audit-Eintrag zurück
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <param name="action">
        /// Durchgeführte Aktion</param>
        /// <returns></returns>
        Task<Audit> GetAsync(string key, string table, AuditAction action);

        /// <summary>
        /// Gibt eine gefilterte Liste von audits zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        IQueryable<AuditWithNames> FilterWithNames(string filter);

        /// <summary>
        /// Gibt eine Liste von Audits zurück
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <returns>Liste von audits</returns>
        Task<List<AuditWithNames>> GetListWithNamesAsync(string key, string table);

        /// <summary>
        /// Gibt eine Liste von Audits zurück
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <param name="action">
        /// Durchgeführte Aktion</param>
        /// <returns>Liste von audits</returns>
        Task<List<AuditWithNames>> GetListWithNamesAsync(string key, string table, AuditAction action);

        /// <summary>
        /// Gibt einen Audit-Eintrag zurück
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <param name="action">
        /// Durchgeführte Aktion</param>
        /// <returns></returns>
        Task<AuditWithNames> GetWithNamesAsync(string key, string table, AuditAction action);

        /// <summary>
        /// Löschen von Audit-Einträgen
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <returns>Anzahl gelöschte Daten</returns>
        Task<int> DeleteAsync(string key, string table);

        /// <summary>
        /// Anonymisieren von Audit-Einträgen
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <returns>Anzahl anonymisierte Daten</returns>
        Task<int> AnonymizeAsync(string key, string table);

        /// <summary>
        /// Loggen des Zugriffs eines Users auf einen Datensatz
        /// </summary>
        /// <param name="key">Key des Objektes</param>
        /// <param name="table">Typ des Objektes (Table)</param>
        /// <param name="userName">Benutzer der den Zugriff durchgeführt hat</param>
        /// <returns>Task</returns>
        Task LogAccessAsync(string key, string table, string userName);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Kunden-Typen realisiert
    /// </summary>
    public interface ICustomerTypeService : IService<CustomerType>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden-Typen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden-Typen</returns>
        IQueryable<CustomerType> Filter(string filter);

        /// <summary>
        /// Erstellen eines Kunden-Typen
        /// </summary>
        /// <returns>Kunden-Type</returns>
        CustomerType Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden-Typen zurück. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden-Typen</returns>
        Task<List<CustomerType>> SearchAsync(string filter);

        /// <summary>
        /// Gibt ein Kunden-Typen zurück
        /// </summary>
        /// <param name="uniqueId">UniqueId des Kunden-Typen</param>
        /// <returns>Betroffener Kunden-Typ</returns>
        Task<CustomerType> GetByUniqueIdAsync(Guid uniqueId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Kunden realisiert
    /// </summary>
    public interface ICustomerService : IService<Customer>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        IQueryable<Customer> Filter(string filter);

        /// <summary>
        /// Erstellen eines Kunden
        /// </summary>
        /// <returns>Kunde</returns>
        Customer Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden zurück. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        Task<List<Customer>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden zurück die ein Mangopay Konto haben. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        Task<List<Customer>> SearchWithMangopayAccountAsync(string filter);

        /// <summary>
        /// Gibt ein Kunden zurück
        /// </summary>
        /// <param name="uniqueId">UniqueId des Kunden</param>
        /// <returns>Betroffener Kunde</returns>
        Task<Customer> GetByUniqueIdAsync(Guid uniqueId);

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden mit Namen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>List betroffener Kunden</returns>
        IQueryable<CustomerWithNames> FilterWithNames(string filter, string language, string fallback);

        /// <summary>
        /// Gibt die nächste freie Nummer für einen Kunden zurück
        /// </summary>
        /// <returns>Kunden-Nummer</returns>
        string GetNextNumber();

        /// <summary>
        /// Zurücksetzen des Kunden-Typs auf null
        /// </summary>
        /// <param name="typeId">Id des Kunden-Typs</param>
        /// <returns>Anzahl zurückgesetzte Kunden</returns>
        Task<int> ResetTypeAsync(long typeId);

        /// <summary>
        /// Zurücksetzen der Branche auf null
        /// </summary>
        /// <param name="branchId">Id der Branche</param>
        /// <returns>Anzahl zurückgesetzte Kunden</returns>
        Task<int> ResetBranchAsync(string branchId);

        /// <summary>
        /// Zurücksetzen der Branchen-Listungen
        /// </summary>
        /// <param name="branchId">Id der Branche</param>
        /// <returns>Anzahl zurückgesetzte Kunden</returns>
        Task<int> ResetBranchListingsAsync(string branchId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von App-Usern realisiert
    /// </summary>
    public interface IAppUserService : IService<AppUser>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von App-Usern zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>List betroffener App-User</returns>
        IQueryable<AppUser> Filter(string filter, bool includeDeleted);

        /// <summary>
        /// Erstellen eines App-Users
        /// </summary>
        /// <returns>App-User</returns>
        AppUser Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von App-Usern zurück. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>List betroffener App-User</returns>
        Task<List<AppUser>> SearchAsync(string filter, bool includeDeleted);

        /// <summary>
        /// Gibt die nächste freie Nummer für einen App-User zurück
        /// </summary>
        /// <returns>App-User-Nummer</returns>
        string GetNextNumber();

        /// <summary>
        /// Gibt die Anzahl von App-UserN im System zurück
        /// </summary>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Anzahl App-User</returns>
        Task<int> CountAsync(bool includeDeleted);

        /// <summary>
        /// Gibt die Anzahl der AppUser im System zurück welche einem Typ entsprechen
        /// </summary>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="type">Typ der gesucht wird</param>
        /// <param name="lastUpdate">Optional: wenn angegeben, dann muss das Datum des letzten Updates größer oder gleich dem lastUpdate Datum sein</param>
        /// <returns>Anzahl AppUser</returns>
        Task<int> CountAsync(bool includeDeleted, AppUserType type, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Entsperren von gesperrten App-Usern deren LockedUntil-Datum erreicht wurde.
        /// </summary>
        /// <returns>Anzahl entsperrte App-User</returns>
        Task<int> AutoUnlockAsync();

        /// <summary>
        /// Gibt eine Liste von App-Usern zurück, die für die automatische Auszahlung in Frage kommen
        /// </summary>
        /// <returns>List App-User</returns>
        Task<List<AppUser>> GetForAutoPayoutAsync();

        /// <summary>
        /// Gibt zurück ob ein App-User gesperrt ist
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>true wenn gesperrt, false sonst</returns>
        Task<bool> IsLockedAsync(string appUserId);

        /// <summary>
        /// Gibt eine List von AppUsern zurück
        /// </summary>
        /// <param name="skip">skip</param>
        /// <param name="take">take</param>
        /// <param name="type">Typ der gesucht wird</param>
        /// <param name="lastUpdate">Optional: wenn angegeben, dann muss das Datum des letzten Updates größer oder gleich dem lastUpdate Datum sein</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste AppUser</returns>
        Task<List<AppUser>> GetAllAsync(int skip, int take, AppUserType type, DateTimeOffset? lastUpdate, bool includeDeleted);

        #region Profil

        /// <summary>
        /// Erstellt ein DogWalker Profil wenn es noch nicht existiert
        /// </summary>
        /// <param name="id">Id des App-Users</param>
        /// <returns>DogWalker Propfil</returns>
        Task<DogWalkerProfile> CreateWalkerProfileIfNotExistsAsync(string id);

        /// <summary>
        /// Gibt ein Walker-Profil für einen App-User zurück
        /// </summary>
        /// <param name="id">Id des App-Users</param>
        /// <returns>DogWalker Propfil</returns>
        Task<DogWalkerProfile> GetWalkerProfileAsync(string id);

        /// <summary>
        /// Löschen eines Walker-Profils für einen App-User
        /// </summary>
        /// <param name="id">Id des App-Users</param>
        /// <returns>DogWalker Propfil</returns>
        Task RemoveWalkerProfileAsync(string id);

        #endregion

        #region DogWalkers

        /// <summary>
        /// Gibt eine Liste Dogwalkern zurück - sortiert nach Distanz
        /// </summary>
        /// <param name="ignoreId">Id des App-Users der ignoriert werden soll, falls ein DogOwner auch Walker ist</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="take">Wie viele sollen max gewählt werden?</param>
        /// <returns>Liste passender Dogwalker</returns>
        Task<List<DogWalker>> GetWalkersForAppAsync(string ignoreId, double lat, double lng, int take);

        /// <summary>
        /// Gibt einen Dogwalker zurück
        /// </summary>
        /// <param name="dogWalkerId">Id des DogWalkers</param>
        /// <returns>DogWalker oder null wenn nicht gefunden</returns>
        Task<DogWalker> GetWalkerAsync(string dogWalkerId);

        /// <summary>
        /// Gibt eine Liste von Dogwalkern zurück
        /// </summary>
        /// <param name="query">Abfrage-Objekt für Dogwalker - Beinhaltet alle Filter und auch Paging</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<DogWalker> list)> GetWalkersAsync(DogWalkerQueryDto query);

        /// <summary>
        /// Gibt eine Liste von Dogwalkern zurück welche über eine Adresse verfügen und deren Standort vom angegebenen Standort nicht weiter als der definierte Radius entfernt sind
        /// </summary>
        /// <param name="ignoreId">Id des Walkers der ignoriert werden soll, falls der hundebesitzer auch Walker ist</param>
        /// <param name="location">Location für die Abholung des Hundes - darf nicht weiter als definierter Radius entfernt sein</param>
        /// <returns>Liste gefundene Walker</returns>
        Task<List<DogWalker>> GetWalkersForNotificationAsync(string ignoreId, Point location);

        #endregion

        #region Systemnachrichten

        /// <summary>
        /// Abfrage des App-Users für eine Systemnachricht
        /// </summary>
        /// <param name="query">Abfrageparameter</param>
        /// <returns>Liste der App-User</returns>
        Task<List<AppUser>> GetForSystemMessageAsync(SystemMessageAppUserQuery query);

        /// <summary>
        /// Gibt zurück wie viele App-User für eine Systemnachricht gefunden werden
        /// </summary>
        /// <param name="query">Abfrageparameter</param>
        /// <returns>Anzahl der App-User</returns>
        Task<int> CountForSystemMessageAsync(SystemMessageAppUserQuery query);

        #endregion

        #region Blocks

        /// <summary>
        /// Erstellen einer Blockierung eines App-Users
        /// </summary>
        /// <returns>AppUserBlock</returns>
        AppUserBlock CreateBlock();

        /// <summary>
        /// Hinzufügen eines Blocks eine App-Users
        /// </summary>
        /// <param name="block">AppUserBlock</param>
        void AddBlock(AppUserBlock block);

        /// <summary>
        /// Blockiert einen App-User für einen anderen, wenn noch kein Block existiert
        /// </summary>
        /// <param name="blockingAppUserId">Id des App-Users der die Blockierung vornimmt</param>
        /// <param name="blockedAppUserId">Id des App-Users der blockiert wird</param>
        /// <param name="createdBy">Von wem erstellt?</param>
        /// <param name="blockUntil">Optional: Bis wann soll der App-User blockiert werden?</param>
        /// <param name="reportId">Optional: Verweis auf eine Meldung</param>
        /// <returns>Erstellte oder existierende Blockierung</returns>
        Task<AppUserBlock> BlockAppUserAsync(string blockingAppUserId, string blockedAppUserId, string createdBy, DateTimeOffset? blockUntil = null, long? reportId = null);

        /// <summary>
        /// Aufheben der Blockierung eines App-Users durch einen anderen, wenn vorhanden
        /// </summary>
        /// <param name="blockingAppUserId">Id des App-Users der die Blockierung vornimmt</param>
        /// <param name="blockedAppUserId">Id des App-Users der blockiert wird</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> UnblockAppUserAsync(string blockingAppUserId, string blockedAppUserId);

        /// <summary>
        /// Löschen einer Blockierung
        /// </summary>
        /// <param name="block">AppUserBlock</param>
        void RemoveBlock(AppUserBlock block);

        /// <summary>
        /// Löschen einer Blockierung
        /// </summary>
        /// <param name="id">Id der Blockierung</param>
        Task RemoveBlockByIdAsync(long id);

        /// <summary>
        /// Entfernen von Blocks eines App-Users der blockiert hat
        /// </summary>
        /// <param name="id">Id des AppUsers der blockiert hat</param>
        /// <returns>Task</returns>
        Task RemoveBlocksByBlockingUserAsync(string id);

        /// <summary>
        /// Entfernen von Blocks eines App-Users der blockiert wurde
        /// </summary>
        /// <param name="id">Id des AppUsers der blockiert wurde</param>
        /// <returns>Task</returns>
        Task RemoveBlocksByBlockedUserAsync(string id);

        /// <summary>
        /// Löschen von abgelaufenen Blockierungen, welche ein Ablaufdatum haben
        /// </summary>
        /// <param name="date">Datum das erreicht werden muss</param>
        /// <returns>Anzahl gelösche Blockierungen</returns>
        Task<int> RemoveExpiredBlocksAsync(DateTimeOffset date);

        /// <summary>
        /// Gibt zurück ob ein App-User von einem anderen blockiert wurde
        /// </summary>
        /// <param name="blockingAppUserId">Id des App-Users der blockiert hat</param>
        /// <param name="blockedAppUserId">Id des App-Users der blockiert wurde</param>
        /// <returns>true wenn blockiert, false sonst</returns>
        Task<bool> IsBlockedAsync(string blockingAppUserId, string blockedAppUserId);

        #endregion

        /// <summary>
        /// Gibt eine Liste von blockierten App-Usern für einen App-User zurück
        /// </summary>
        /// <param name="query">Abfrageparameter</param>
        /// <returns>Liste von gesperrten App-Usern</returns>
        Task<(int total, List<AppUserBlockWithNames> list)> GetBlockedAppUsersAsync(BlockedQueryDto query);

        /// <summary>
        /// Gibt eine Liste von AppUsern zurück welche als geöscht markiert sind
        /// </summary>
        /// <returns>Liste AppUser</returns>
        Task<List<AppUser>> GetDeletedAsync();

        /// <summary>
        /// Gibt eine Liste von AppUsern zurück deren Location nicht valide ist
        /// </summary>
        /// <returns>Liste AppUser</returns>
        Task<List<AppUser>> GetWithInvalidLocationAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Rubriken realisiert
    /// </summary>
    public interface IAdvertisementCategoryService : IService<AdvertisementCategory>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Rubriken zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Rubriken</returns>
        IQueryable<AdvertisementCategory> Filter(string filter);

        /// <summary>
        /// Erstellen einer Rubrik
        /// </summary>
        /// <returns>Kunde</returns>
        AdvertisementCategory Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Rubriken zurück. Sucht nur im Titel
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Rubriken</returns>
        Task<List<AdvertisementCategory>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Rubriken mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Rubriken</returns>
        IQueryable<AdvertisementCategoryWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Kategorien zurück die Online sind
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste betroffener Rubriken</returns>
        Task<List<AdvertisementCategoryWithNames>> GetOnlineWithNamesAsync(string language, string fallback);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Versandkosten ermöglicht
    /// </summary>
    public interface IShipmentCostService : IService<ShipmentCost>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Versandkosten zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Versandkosten</returns>
        IQueryable<ShipmentCost> Filter(string filter);

        /// <summary>
        /// Erstellen von Versandkosten
        /// </summary>
        /// <returns>Versandkosten</returns>
        ShipmentCost Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Versandkosten zurück. Sucht nur im Land
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Versandkosten</returns>
        Task<List<ShipmentCost>> SearchAsync(string filter);

        /// <summary>
        /// Berechnen der Versandkosten
        /// </summary>
        /// <param name="targetCountry">Zielland</param>
        /// <param name="weight">Gewicht</param>
        /// <param name="subtotal">Zwischensumme netto</param>
        /// <param name="additionalShipmentCosts">Summe der zusätzlichen Versandkosten je Produkt aber in Summe</param>
        /// <returns>Versandkosten netto</returns>
        Task<decimal> CalculateShipmentAsync(string targetCountry, decimal weight, decimal subtotal, decimal additionalShipmentCosts);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Steuern realisiert
    /// </summary>
    public interface ITaxRateService : IService<TaxRate>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Steuern zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Steuern</returns>
        IQueryable<TaxRate> Filter(string filter);

        /// <summary>
        /// Erstellen einer Steuer
        /// </summary>
        /// <returns>Steuer</returns>
        TaxRate Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Steuern zurück. Sucht nur im Titel
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hundeausführern</returns>
        Task<List<TaxRate>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Steuern mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache falls keine Übersetzung vorhanden</param>
        /// <returns>Liste betroffener Steuern</returns>
        IQueryable<TaxRateWithNames> FilterWithNames(string filter, string language, string fallback);

        /// <summary>
        /// Prüft ob für ein Land schon eine Steuer mit einem Wert existiert
        /// </summary>
        /// <param name="countryIso">Land ISO2</param>
        /// <param name="value">Steuer-Wert</param>
        /// <returns>true wenn existiert, false sonst</returns>
        Task<bool> ExistsAsync(string countryIso, decimal value);

        /// <summary>
        /// Zurücksetzen wird für Versandkosten verwendet
        /// </summary>
        /// <param name="excludeId">Id die ausgenommen werden soll</param>
        /// <returns>Task</returns>
        Task ResetShipmentAsync(int excludeId);

        /// <summary>
        /// Gibt den Steuersatz für Versandkosten zurück
        /// </summary>
        /// <returns>Versandkosten-Steuersatz in Prozent</returns>
        Task<decimal> GetForShipmentAsync();

        /// <summary>
        /// Berechnen eines Brutto-Wertes für einen Preis
        /// </summary>
        /// <param name="value">Preis netto</param>
        /// <param name="taxRateId">Id der Steuerstufe</param>
        /// <param name="sourceCountry">QuellLand des Shops</param>
        /// <param name="targetCountry">Zielland</param>
        /// <returns>Brutto-Wert</returns>
        Task<TaxGrossResult> CalculateGrossAsync(decimal value, int taxRateId, string sourceCountry, string targetCountry);

        /// <summary>
        /// Berechnen eines Brutto-Wertes für Versandkosten
        /// </summary>
        /// <param name="value">Preis netto</param>
        /// <param name="sourceCountry">QuellLand des Shops</param>
        /// <param name="targetCountry">Zielland</param>
        /// <returns>Brutto-Wert</returns>
        Task<TaxGrossResult> CalculateShipmentGrossAsync(decimal value, string sourceCountry, string targetCountry);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Produktkategorien realisiert
    /// </summary>
    public interface IProductCategoryService : IService<ProductCategory>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Produktkategorien zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Produktkategorien</returns>
        IQueryable<ProductCategory> Filter(string filter);

        /// <summary>
        /// Erstellen einer Produktkategorie
        /// </summary>
        /// <returns>Produktkategorie</returns>
        ProductCategory Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Produktkategorien mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Produktkategorien</returns>
        IQueryable<ProductCategoryWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine gefilterte Liste von Produktkategorien mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="parentId">Id des PArents oder null wenn root</param>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Produktkategorien</returns>
        IQueryable<ProductCategoryWithNames> FilterWithNames(int? parentId, string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Erstellen eines Kategorie-Baums
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="excludeId">ID die ausgeschlossen werden soll, wenn es um die Auswahl eines Parents geht</param>
        /// <param name="includeDeleted">Sollen gelöschte Kategorien inkludiert werden?</param>
        /// <returns>Kategorie-Baum</returns>
        Task<List<ProductCategoryWithNamesTree>> GetTreeAsync(string language, string fallback, int excludeId = -1, bool includeDeleted = false);

        /// <summary>
        /// Erstellen eines Kategorie-Baums für Kunden
        /// </summary>
        /// <param name="orderSource">Quelle - für wen holen?</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="excludeId">ID die ausgeschlossen werden soll, wenn es um die Auswahl eines Parents geht</param>
        /// <param name="includeDeleted">Sollen gelöschte Kategorien inkludiert werden?</param>
        /// <returns>Kategorie-Baum</returns>
        Task<List<ProductCategoryWithNamesTree>> GetTreeAsync(OrderSource orderSource, string language, string fallback, int excludeId = -1, bool includeDeleted = false);

        /// <summary>
        /// Setzen einer neuen ParentId für Kateorien
        /// </summary>
        /// <param name="oldId">Alte Id welche ersetzt werden soll</param>
        /// <param name="newId">Neue Id die gesetzt werden soll. Kann auch NULL sein, was bedeutet, dass root gesetzt werden soll</param>
        /// <returns></returns>
        Task<int> ResetParentAsync(int oldId, int? newId);

        /// <summary>
        /// Gibt zurück ob eine Kategorie Kinder hat
        /// </summary>
        /// <param name="id">Id der Kategorie</param>
        /// <returns>true wenn ja, false sonst</returns>
        Task<bool> HasChildrenAsync(int id);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Artikeln / Produkten ermöglicht
    /// </summary>
    public interface IProductService : IService<Product>
    {
        /// <summary>
        /// Erstellen eines Produktes
        /// </summary>
        /// <returns>Produkt</returns>
        Product Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Produkten mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Produkte</returns>
        IQueryable<ProductWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Prüft ob für einen Listungstypen und eine Branche schon ein Produkt existiert
        /// </summary>
        /// <param name="listingType">Listungstyp</param>
        /// <param name="branchId">Branche</param>
        /// <returns>true wenn existiert, false sonst</returns>
        Task<bool> CheckListingExistsAsync(ListingType listingType, string branchId);

        /// <summary>
        /// Prüft ob für einen Listungstypen und eine Branche schon ein Produkt existiert
        /// </summary>
        /// <param name="listingType">Listungstyp</param>
        /// <param name="branchId">Branche</param>
        /// <param name="priceType">Preistyp</param>
        /// <returns>true wenn existiert, false sonst</returns>
        Task<bool> CheckListingExistsAsync(ListingType listingType, string branchId, PriceType priceType);

        /// <summary>
        /// Prüft ob für eine Rubrik schon ein Produkt für Werbung existiert
        /// </summary>
        /// <param name="advertisementCategoryId">Rubrik</param>
        /// <returns>true wenn existiert, false sonst</returns>
        Task<bool> CheckAdvertisementExistsAsync(string advertisementCategoryId);

        /// <summary>
        /// Gibt zurück wie viele nicht gelöschte Produkte eine Rubrik verwenden
        /// </summary>
        /// <param name="advertisementCategoryId">Id der Rubrik</param>
        /// <returns>Anzahl der Produkte die eine Rubrik verwenden</returns>
        Task<int> CountByAdvertisementCategoryAsync(string advertisementCategoryId);

        /// <summary>
        /// Setzt für Produkte die Rubrik zurück
        /// </summary>
        /// <param name="advertisementCategoryId">Id der Rubrik</param>
        /// <param name="deletedOnly">true wenn nur gelöschte Produkte zurückgesetzt werden sollen</param>
        /// <returns>Anzahl Produkte zurückgesetzt</returns>
        Task<int> ResetAdvertisementCategoryAsync(string advertisementCategoryId, bool deletedOnly);

        /// <summary>
        /// Setzt für Produkte die Produktkategorie zurück
        /// </summary>
        /// <param name="categoryId">Id der Produktkategorie</param>
        /// <param name="deletedOnly">true wenn nur gelöschte Produkte zurückgesetzt werden sollen</param>
        /// <returns>Anzahl Produkte zurückgesetzt</returns>
        Task<int> ResetProductCategoryAsync(int categoryId, bool deletedOnly);

        /// <summary>
        /// Gibt zurück wie viele Produkte eine Steuergruppe verwenden
        /// </summary>
        /// <param name="taxRateId">Id der Steuergruppe</param>
        /// <returns>Anzahl der Produkte die eine Steuergruppe verwenden</returns>
        Task<int> CountByTaxRateAsync(int taxRateId);

        /// <summary>
        /// Gibt eine gefilterte Liste von Produkteinstellungen für Länder zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="productId">Id des Produktes</param>
        /// <returns>Liste betroffener Produkteinstellungen</returns>
        IQueryable<ProductCountry> FilterCountry(string filter, int productId);

        /// <summary>
        /// Gibt eine Produkteinstellung für ein Land zurück
        /// </summary>
        /// <param name="id">Id der Einstellung</param>
        /// <returns>Produkteinstellung oder null, wenn nicht gefunden</returns>
        Task<ProductCountry> GetCountryAsync(int id);

        /// <summary>
        /// Gibt eine Produkteinstellung für ein Land zurück
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <param name="countryIso">Land ISO2</param>
        /// <returns>Produkteinstellung oder null, wenn nicht gefunden</returns>
        Task<ProductCountry> GetCountryAsync(int productId, string countryIso);

        /// <summary>
        /// Erstellen einer Produkteinstellung für ein Land
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <param name="countryIso">ISO2 Land</param>
        /// <returns>Produkteinstellung</returns>
        ProductCountry CreateCountry(int productId, string countryIso);

        /// <summary>
        /// Hinzufügen einer Produkteinstellung für ein Land
        /// </summary>
        /// <param name="productCountry">Produkteinstellung</param>
        void AddCountry(ProductCountry productCountry);

        /// <summary>
        /// Löschen einer Produkteinstellung für ein Land
        /// </summary>
        /// <param name="productCountry">Produkteinstellung</param>
        void RemoveCountry(ProductCountry productCountry);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Listung zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="allowedBranches">Branchen des Kunden</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkten</returns>
        Task<List<ProductWithNamesCountry>> GetListingProductsAsync(OrderSource orderSource, string countryIso, string allowedBranches, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Listung zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="allowedBranches">Branchen des Kunden</param>
        /// <param name="categories">Gewählte Produktkategorien</param>
        /// <param name="filter">Filtertext für Name</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkten</returns>
        Task<List<ProductWithNamesCountry>> GetListingProductsAsync(OrderSource orderSource, string countryIso, string allowedBranches, List<int> categories, string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Werbung zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkte</returns>
        Task<List<ProductWithNamesCountry>> GetAdvertisementProductsAsync(OrderSource orderSource, string countryIso, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Werbung zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="categories">Gewählte Produktkategorien</param>
        /// <param name="filter">Filtertext für Name</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkte</returns>
        Task<List<ProductWithNamesCountry>> GetAdvertisementProductsAsync(OrderSource orderSource, string countryIso, List<int> categories, string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Banner zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkte</returns>
        Task<List<ProductWithNamesCountry>> GetBannerProductsAsync(OrderSource orderSource, string countryIso, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Banner zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="categories">Gewählte Produktkategorien</param>
        /// <param name="filter">Filtertext für Name</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkte</returns>
        Task<List<ProductWithNamesCountry>> GetBannerProductsAsync(OrderSource orderSource, string countryIso, List<int> categories, string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Pin zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkte</returns>
        Task<List<ProductWithNamesCountry>> GetPinProductsAsync(OrderSource orderSource, string countryIso, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Produkten vom Typ Pin zurück
        /// </summary>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="categories">Gewählte Produktkategorien</param>
        /// <param name="filter">Filtertext für Name</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Produkte</returns>
        Task<List<ProductWithNamesCountry>> GetPinProductsAsync(OrderSource orderSource, string countryIso, List<int> categories, string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt ein Produkt mit Daten für Land und Sprache erweitert zurück.
        /// Es wird geprüft ob der kunde auch Zugriff auf das Produkt hat.
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <param name="orderSource">Für welchen Typen? Kunde, Hundebesitzer, Hundeausführer</param>
        /// <param name="countryIso">Land</param>
        /// <param name="language">Sprache</param>
        /// <param name="fallback">Facllback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Produkt</returns>
        Task<ProductWithNamesCountry> GetWithNamesCountryAsync(int productId, OrderSource orderSource, string countryIso, string language, string fallback, bool includeDeleted);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Warenkörben realisiert
    /// </summary>
    public interface ICartService : IService<Cart>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Warenkörben zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Prache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>List betroffener Warenkörbe</returns>
        IQueryable<CartWithNames> Filter(string filter, string language, string fallback);

        /// <summary>
        /// Erstellen eines Warenkorbes
        /// </summary>
        /// <param name="billingCountry">Rechnungsland</param>
        /// <param name="deliveryCountry">Lieferland</param>
        /// <returns>Warenkorb</returns>
        Cart Create(string billingCountry, string deliveryCountry);

        /// <summary>
        /// Erstellen eines Warenkorbes für einen Kunden
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="billingCountry">Rechnungsland</param>
        /// <param name="deliveryCountry">Lieferland</param>
        /// <returns>Warenkorb</returns>
        Cart CreateForCustomer(long customerId, string billingCountry, string deliveryCountry);

        /// <summary>
        /// Erstellen eines Warenkorbes für einen App-User
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="orderSource">Quelle</param>
        /// <param name="billingCountry">Rechnungsland</param>
        /// <param name="deliveryCountry">Lieferland</param>
        /// <returns>Warenkorb</returns>
        Cart CreateForAppUser(string appUserId, OrderSource orderSource, string billingCountry, string deliveryCountry);

        /// <summary>
        /// Gibt einen Warenkorb für einen Kunden zurück oder legt einen an
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="billingCountry">Rechnungsland</param>
        /// <param name="deliveryCountry">Lieferland</param>
        /// <param name="userName">Benutzer der den Warenkorb anlegt</param>
        /// <returns>Warenkorb</returns>
        Task<Cart> GetOrCreateCustomerAsync(long customerId, string billingCountry, string deliveryCountry, string userName);

        /// <summary>
        /// Gibt einen Warenkorb für einen App-User zurück oder legt einen an
        /// </summary>
        /// <param name="appUserId">Id des Hundebesitzers</param>
        /// <param name="orderSource">Quelle</param>
        /// <param name="billingCountry">Rechnungsland</param>
        /// <param name="deliveryCountry">Lieferland</param>
        /// <param name="userName">Benutzer der den Warenkorb anlegt</param>
        /// <returns>Warenkorb</returns>
        Task<Cart> GetOrCreateAppUserAsync(string appUserId, OrderSource orderSource, string billingCountry, string deliveryCountry, string userName);

        /// <summary>
        /// Gibt einen Warenkorb für einen Kunden zurück
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <returns>Warenkorb oder null, wenn nicht gefunden</returns>
        Task<Cart> GetByCustomerAsync(long customerId);

        /// <summary>
        /// Gibt einen Warenkorb für einen App-Users zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>Warenkorb oder null, wenn nicht gefunden</returns>
        Task<Cart> GetByAppUserAsync(string appUserId);

        /// <summary>
        /// Gibt einen Warenkorb für einen Kunden zurück
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="language">Gewünschte Prache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Warenkorb oder null, wenn nicht gefunden</returns>
        Task<CartWithNames> GetByCustomerWithNamesAsync(long customerId, string language, string fallback);

        /// <summary>
        /// Gibt einen Warenkorb für einen App-User zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="language">Gewünschte Prache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Warenkorb oder null, wenn nicht gefunden</returns>
        Task<CartWithNames> GetByAppUserWithNamesAsync(string appUserId, string language, string fallback);

        /// <summary>
        /// Anlegen eines Artikels für den Warenkorb
        /// </summary>
        /// <returns>Warenkorb Artikel</returns>
        CartItem CreateItem();

        /// <summary>
        /// Hinzufügen eines Artikels zum Warenkorb
        /// </summary>
        /// <param name="item">Artikel</param>
        void AddItem(CartItem item);

        /// <summary>
        /// Gibt einen Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartId">Id des Warenkorbs</param>
        /// <param name="productId">Id des Artikels</param>
        /// <returns>Artikel im Warenkorb oder null, wenn nicht gefunden</returns>
        Task<CartItem> GetItemAsync(long cartId, int productId);

        /// <summary>
        /// Gibt einen Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartItemId">Id des Artikels im Warenkorbs</param>
        /// <returns>Artikel im Warenkorb oder null, wenn nicht gefunden</returns>
        Task<CartItem> GetItemAsync(long cartItemId);

        /// <summary>
        /// Gibt eine Liste von Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartId">Id des Warenkorbs</param>
        /// <returns>Liste der Artikel im Warenkorb</returns>
        Task<List<CartItem>> GetItemsAsync(long cartId);

        /// <summary>
        /// Gibt eine Liste von Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartId">Id des Warenkorbs</param>
        /// <param name="language">Gewünschte Prache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste der Artikel im Warenkorb</returns>
        Task<List<CartItemWithNames>> GetItemsWithNamesAsync(long cartId, string language, string fallback);

        /// <summary>
        /// Aktualisieren oder Anlegen eines Artikels im Warenkorb.
        /// Achtung: Es wird keine Berechnung durchgeführt. Dazu den Warenkorb neu berechnen lassen!
        /// </summary>
        /// <param name="cartId">Id des Warenkorbs</param>
        /// <param name="productId">Id des Artikels</param>
        /// <param name="quantity">Stückzahl</param>
        /// <param name="userName">Benutzer der den Warenkorb anlegt</param>
        /// <returns>Warenkorb Artikel oder null, wenn Fehler</returns>
        Task<CartItem> UpdateOrCreateItemAsync(long cartId, int productId, int quantity, string userName);

        /// <summary>
        /// Berechnen eines Warenkorbes
        /// </summary>
        /// <param name="cartId">Id des Warenkorbes</param>
        /// <param name="orderSource">Quelle dser Bestellung - Typ des Benutzers</param>
        /// <param name="targetCountry">Zielland für Versandkostenberechnung</param>
        /// <param name="userName">Benutzer der die Kalkulation anstösst</param>
        /// <returns>Berechneter Warenkorb</returns>
        Task<Cart> CalculateAsync(long cartId, OrderSource orderSource, string targetCountry, string userName);

        /// <summary>
        /// Leeren des Warenkorbs
        /// </summary>
        /// <param name="cartId">Id des Warenkorbes</param>
        /// <param name="removeEntity">Wenn true, werden Entitäten wie Listings, Banner, Werbungen und Pins gelöscht, wenn false werden die Cart- und CartItem Id´s auf null gesetzt</param>
        /// <param name="userName">Benutzer der die Aktion anstösst</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> ClearAsync(long cartId, bool removeEntity, string userName);

        /// <summary>
        /// Löschen eines Artikels aus dem Warenkorb nach ArtikelId
        /// </summary>
        /// <param name="cartItemId">Id des Artikels</param>
        /// <returns>Task</returns>
        Task DeleteCartItemAsync(long cartItemId);

        /// <summary>
        /// Löschen eines Artikels aus dem Warenkorb nach ProduktId
        /// </summary>
        /// <param name="productId">Id des Produktes</param>
        /// <returns>Task</returns>
        Task DeleteCartItemByProductAsync(int productId);

        /// <summary>
        /// Löschen eines Warenkorbs nach Kunden
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <returns>Task</returns>
        Task DeleteByCustomerAsync(long customerId);

        /// <summary>
        /// Löschen eines Warenkorbs nach App-User
        /// </summary>
        /// <param name="appUserId">Id des Hundebesitzers</param>
        /// <returns>Task</returns>
        Task DeleteByAppUserAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung Shop-Einstellungen realisiert
    /// </summary>
    public interface IShopSettingsService : IService<ShopSettings>
    {
        /// <summary>
        /// Gibt die aktuellen Shop-Einstellungen zurück
        /// </summary>
        /// <returns>ShopSettings</returns>
        Task<ShopSettings> GetAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Branchen realisiert
    /// </summary>
    public interface IBranchService : IService<Branch>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Branchen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Branchen</returns>
        IQueryable<Branch> Filter(string filter);

        /// <summary>
        /// Erstellen einer Branche
        /// </summary>
        /// <returns>Branche</returns>
        Branch Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Branchen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Branchen</returns>
        Task<List<Branch>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Branchen mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Branchen</returns>
        IQueryable<BranchWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine gefilterte Liste von Branchen mit Namen zurück in einer gewählten Sprache welche für eine Listung aktiviert sind
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Branchen</returns>
        IQueryable<BranchWithNames> FilterWithNamesListings(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Branchen in einer gewählten Sprache zurück, welche online sind
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste von Branchen</returns>
        Task<List<BranchWithNames>> GetOnlineAsync(string language, string fallback);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Listings realisiert
    /// </summary>
    public interface IListingService : IService<Listing>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Listings zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Listings</returns>
        IQueryable<Listing> Filter(string filter);

        /// <summary>
        /// Erstellen einer Listung
        /// </summary>
        /// <returns>Listung</returns>
        Listing Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Listings zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Listings</returns>
        Task<List<Listing>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Listings mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Listings</returns>
        IQueryable<ListingWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt eine gefilterte Liste von Listings mit Namen für Kunden zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Listings</returns>
        IQueryable<ListingWithNames> FilterWithNamesCustomer(long customerId, string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Löschen von Listungen basierend auf einer Branche
        /// </summary>
        /// <param name="branchId">Id der Branche</param>
        /// <param name="forceDelete">Wenn true, dann wirklich löschen, auf gelöscht setzen sonst</param>
        /// <returns>Task</returns>
        Task DeleteByBranchAsync(string branchId, bool forceDelete);

        /// <summary>
        /// Prüfen der Verfügbarkeit einer Listung für eine Buchung
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="branchId">Id der Branche</param>
        /// <param name="listingType">Listungs-Typ</param>
        /// <param name="startDate">Startdatum</param>
        /// <param name="endDate">Enddatum</param>
        /// <param name="countryIso">ISO2 des Landes</param>
        /// <param name="ignoreId">Id die ignoriert werden soll</param>
        /// <returns>ListingValidationResult</returns>
        Task<ListingValidationResult> IsAvailableAsync(long customerId, string branchId, ListingType listingType, DateTimeOffset startDate, DateTimeOffset endDate, string countryIso, string ignoreId);

        /// <summary>
        /// Gibt die Anzahl von Listungen zurück
        /// </summary>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Anzahl Listungen</returns>
        Task<int> CountAsync(bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt die Anzahl von Listungen in einem Status zurück
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Anzahl Listungen</returns>
        Task<int> CountAsync(ListingStatus status, bool includeDeleted);

        /// <summary>
        /// Prüft ob sich eine Listung bereits im Warenkorb befindet.
        /// Listungen mit bestimmten Parametern dürfen nur einmal vorkommen
        /// </summary>
        /// <param name="cartId">Id des Warenkorb</param>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="branchId">Id der Branche</param>
        /// <param name="listingType">Listungs-Typ</param>
        /// <param name="startDate">Startdatum</param>
        /// <param name="endDate">Enddatum</param>
        /// <param name="countryIso">ISO2 des Landes</param>
        /// <param name="ignoreId">Id die ignoriert werden soll</param>
        /// <returns>True wenn die Listung gefunden wurde, false sonst</returns>
        Task<bool> CheckListingInCartAsync(long cartId, long customerId, string branchId, ListingType listingType, DateTimeOffset startDate, DateTimeOffset endDate, string countryIso, string ignoreId);

        /// <summary>
        /// Gibt eine Listung für einen Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartItemId">Id des Artikels im Warenkorb</param>
        /// <returns>Listing oder null, wenn nicht gefunden</returns>
        Task<Listing> GetByCartItemAsync(long cartItemId);

        /// <summary>
        /// Gibt eine Listung für einen Artikel in einer Bestellung zurück
        /// </summary>
        /// <param name="orderItemId">Id des Artikels in der Bestellung</param>
        /// <returns>Listing oder null, wenn nicht gefunden</returns>
        Task<Listing> GetByOrderItemAsync(long orderItemId);

        /// <summary>
        /// Setzen des Status von Listungen nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <param name="reservedDate">Datum das für die Reservierung gesetzt werden soll</param>
        /// <returns>Anzahl betroffener Listungen</returns>
        Task<int> SetStatusByOrderAsync(long orderId, ListingStatus status, DateTimeOffset? reservedDate);

        /// <summary>
        /// Setzen des Bezahlstatus von Listingen nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Listungen</returns>
        Task<int> SetPaymentStatusByOrderAsync(long orderId, PaymentStatus status);

        /// <summary>
        /// Zurücksetzen von Reservierungen wenn eine Zeit erreicht ist
        /// </summary>
        /// <param name="reservedDate">Obere Grenze der Reservierung</param>
        /// <returns>Anzahl betroffener Listungen</returns>
        Task<int> ResetReservedAsync(DateTimeOffset reservedDate);

        /// <summary>
        /// Gibt eine Liste von Listungen zurück für die Anzeige der Partner in der Nähe
        /// </summary>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste passender Listungen</returns>
        Task<(int total, List<ListingWithNames> list)> GetNearForAppAsync(string country, string state, double lat, double lng, string language, string fallback, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von Listungen zurück für eine Branche zurück.
        /// Die Sortierung erfolgt nach Listungstyp und dann nach Distanz
        /// </summary>
        /// <param name="branchId">Id der Branche</param>
        /// <param name="filter">Optional: Filter für Name und/oder Ort</param>
        /// <param name="listingCountry">Optional: Listings-Land</param>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste passender Listungen</returns>
        Task<(int total, List<ListingWithNames> list)> GetByBranchForAppAsync(string branchId, string filter, string listingCountry, string country, string state, double lat, double lng, string language, string fallback, int skip, int take);

        /// <summary>
        /// Gibt eine Listung in einer gewünschten Sprache zurück
        /// </summary>
        /// <param name="id">Id der Listung</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Gefundene Werbung, null sonst</returns>
        Task<ListingWithNames> GetRunningWithNamesAsync(string id, string language, string fallback);

        /// <summary>
        /// Starten von gebuchten Listungen wenn diese das Start-Datum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestartete Listungen</returns>
        Task<int> StartBookedAsnyc();

        /// <summary>
        /// Stoppen von abgelaufenen Listungen wenn diese das Enddatum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestoppte Listungen</returns>
        Task<int> StopRunningAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Werbungen realisiert
    /// </summary>
    public interface IAdvertisementService : IService<Advertisement>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Werbungen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Werbungen</returns>
        IQueryable<Advertisement> Filter(string filter);

        /// <summary>
        /// Erstellen einer Werbung
        /// </summary>
        /// <returns>Listung</returns>
        Advertisement Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Werbungen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Werbungen</returns>
        Task<List<Advertisement>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Werbungen mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Werbungen</returns>
        IQueryable<AdvertisementWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt eine gefilterte Liste von Werbungen mit Namen für Kunden zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Werbungen</returns>
        IQueryable<AdvertisementWithNames> FilterWithNamesCustomer(long customerId, string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);
        
        /// <summary>
        /// Löschen von Werbungen basierend auf einer Rubrik
        /// </summary>
        /// <param name="categoryId">Id der Rubrik</param>
        /// <param name="forceDelete">Wenn true, dann wirklich löschen, auf gelöscht setzen sonst</param>
        /// <returns>Task</returns>
        Task DeleteByCategoryAsync(string categoryId, bool forceDelete);

        /// <summary>
        /// Gibt die Anzahl von Werbungen zurück
        /// </summary>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Anzahl Werbungen</returns>
        Task<int> CountAsync(bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt die Anzahl von Werbungen in einem Status zurück
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Anzahl Werbungen</returns>
        Task<int> CountAsync(AdvertisementStatus status, bool includeDeleted);

        /// <summary>
        /// Gibt eine Werbung für einen Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartItemId">Id des Artikels im Warenkorb</param>
        /// <returns>Werbung oder null, wenn nicht gefunden</returns>
        Task<Advertisement> GetByCartItemAsync(long cartItemId);

        /// <summary>
        /// Gibt eine Werbung für einen Artikel in einer Bestellung zurück
        /// </summary>
        /// <param name="orderItemId">Id des Artikels in der Bestellung</param>
        /// <returns>Werbung oder null, wenn nicht gefunden</returns>
        Task<Advertisement> GetByOrderItemAsync(long orderItemId);

        /// <summary>
        /// Setzen des Status von Werbungen nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Werbungen</returns>
        Task<int> SetStatusByOrderAsync(long orderId, AdvertisementStatus status);

        /// <summary>
        /// Setzen des Bezahlstatus von Werbungen nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Werbungen</returns>
        Task<int> SetPaymentStatusByOrderAsync(long orderId, PaymentStatus status);

        /// <summary>
        /// Gibt eine Liste von Werbungen zurück für die Anzeige der Werbungen die bald enden und  in der Nähe sind
        /// </summary>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste passender Listungen</returns>
        Task<(int total, List<AdvertisementWithNames> list)> GetNearEndForAppAsync(string country, string state, double lat, double lng, string language, string fallback, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von Werbungen je Kategorie zurück
        /// </summary>
        /// <param name="categoryId">Id der Kategorie</param>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste passender Listungen</returns>
        Task<(int total, List<AdvertisementWithNames> list)> GetByCategoryForAppAsync(string categoryId, string country, string state, double lat, double lng, string language, string fallback, int skip, int take);

        /// <summary>
        /// Gibt eine Werbung in einer gewünschten Sprache zurück
        /// </summary>
        /// <param name="id">Id der Werbung</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Gefundene Werbung, null sonst</returns>
        Task<AdvertisementWithNames> GetRunningWithNamesAsync(string id, string language, string fallback);

        /// <summary>
        /// Starten von gebuchten Werbungen wenn diese das Start-Datum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestartete Werbungen</returns>
        Task<int> StartBookedAsnyc();

        /// <summary>
        /// Stoppen von abgelaufenen Werbungen wenn diese das Enddatum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestoppte Werbungen</returns>
        Task<int> StopRunningAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Bannern realisiert
    /// </summary>
    public interface IBannerService : IService<Banner>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Bannern zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Banner</returns>
        IQueryable<Banner> Filter(string filter);

        /// <summary>
        /// Erstellen eines Banners
        /// </summary>
        /// <returns>Banner</returns>
        Banner Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Bannern zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Banner</returns>
        Task<List<Banner>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Bannern mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Banner</returns>
        IQueryable<BannerWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt eine gefilterte Liste von Bannern mit Namen für Kunden zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Banner</returns>
        IQueryable<BannerWithNames> FilterWithNamesCustomer(long customerId, string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt die Anzahl von Bannern zurück
        /// </summary>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Anzahl Banner</returns>
        Task<int> CountAsync(bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt die Anzahl von Bannern in einem Status zurück
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Anzahl Banner</returns>
        Task<int> CountAsync(BannerStatus status, bool includeDeleted);

        /// <summary>
        /// Gibt einen Banner für einen Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartItemId">Id des Artikels im Warenkorb</param>
        /// <returns>Banner oder null, wenn nicht gefunden</returns>
        Task<Banner> GetByCartItemAsync(long cartItemId);

        /// <summary>
        /// Gibt einen Banner für einen Artikel in einer Bestellung zurück
        /// </summary>
        /// <param name="orderItemId">Id des Artikels in der Bestellung</param>
        /// <returns>Banner oder null, wenn nicht gefunden</returns>
        Task<Banner> GetByOrderItemAsync(long orderItemId);

        /// <summary>
        /// Setzen des Status von Bannern nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Banner</returns>
        Task<int> SetStatusByOrderAsync(long orderId, BannerStatus status);

        /// <summary>
        /// Setzen des Bezahlstatus von Bannern nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Banner</returns>
        Task<int> SetPaymentStatusByOrderAsync(long orderId, PaymentStatus status);

        /// <summary>
        /// Gibt einen Banner für eine Platzierung zurück
        /// </summary>
        /// <param name="bannerLocation">Platzierung des Banners</param>
        /// <param name="currentBannerId">Optional: Id des Banners der gerade angezeigt wird</param>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Zufälliger Banner wenn gefunden, null sonst</returns>
        Task<BannerWithNames> GetBannerForLocationAsync(BannerLocation bannerLocation, string currentBannerId, string country, string state, double lat, double lng, string language, string fallback);

        /// <summary>
        /// Fügt eine Anzahl von Views zu einem Banner hinzu und beendet die Laufzeit wenn die Budgetgrenze erreicht wurde
        /// </summary>
        /// <param name="id">Id des Banners</param>
        /// <param name="viewCount">Anzahl Views</param>
        /// <param name="appMode">AppMode</param>
        /// <param name="language">Sprache</param>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <returns>Anzahl Views gesamt</returns>
        Task<int> AddViewsAsync(string id, int viewCount, AppMode appMode, string language, string country, string state);

        /// <summary>
        /// Fügt eine Anzahl von Klicks zu einem Banner hinzu und beendet die Laufzeit wenn die Budgetgrenze erreicht wurde
        /// </summary>
        /// <param name="id">Id des Banners</param>
        /// <param name="clickCount">Anzahl Klicks</param>
        /// <param name="appMode">AppMode</param>
        /// <param name="language">Sprache</param>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <returns>Anzahl Klicks gesamt</returns>
        Task<int> AddClicksAsync(string id, int clickCount, AppMode appMode, string language, string country, string state);

        /// <summary>
        /// Hinzufügen einer Statstik für einen Banner
        /// </summary>
        /// <param name="id">Id des Banners</param>
        /// <param name="appMode">AppMode</param>
        /// <param name="type">Klick oder View</param>
        /// <param name="value">Anzahl Klicks oder Views</param>
        /// <param name="language">Sprache</param>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <returns>Task</returns>
        void AddStatistic(string id, AppMode appMode, BannerStatisticType type, int value, string language, string country, string state);

        /// <summary>
        /// Starten von gebuchten Bannern wenn diese das Start-Datum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestartete Banner</returns>
        Task<int> StartBookedAsnyc();

        /// <summary>
        /// Stoppen von abgelaufenen Bannern wenn diese das Enddatum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestoppte Banner</returns>
        Task<int> StopRunningAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Pins realisiert
    /// </summary>
    public interface IPinService : IService<Pin>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Pins zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Pins</returns>
        IQueryable<Pin> Filter(string filter);

        /// <summary>
        /// Erstellen eines Pins
        /// </summary>
        /// <returns>Pin</returns>
        Pin Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Pins zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Pins</returns>
        Task<List<Pin>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Pins mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Pins</returns>
        IQueryable<PinWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt eine gefilterte Liste von Pins mit Namen für Kunden zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Pins</returns>
        IQueryable<PinWithNames> FilterWithNamesCustomer(long customerId, string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Zurücksetzen der Zuordnung zu einer Listung
        /// </summary>
        /// <param name="listingId">Id der Listung</param>
        /// <returns>Task</returns>
        Task<int> ResetListingAsync(string listingId);

        /// <summary>
        /// Stornieren eines Pins basierend auf einer Listung
        /// </summary>
        /// <param name="listingId">Id der Listung</param>
        /// <returns>Task</returns>
        Task<int> CancelByListingAsync(string listingId);

        /// <summary>
        /// Gibt die Anzahl von Pins zurück
        /// </summary>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Anzahl Pins</returns>
        Task<int> CountAsync(bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt die Anzahl von Pins in einem Status zurück
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Anzahl Pins</returns>
        Task<int> CountAsync(PinStatus status, bool includeDeleted);

        /// <summary>
        /// Gibt einen Pin für einen Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartItemId">Id des Artikels im Warenkorb</param>
        /// <returns>Pin oder null, wenn nicht gefunden</returns>
        Task<Pin> GetByCartItemAsync(long cartItemId);

        /// <summary>
        /// Gibt einen Pin für einen Artikel in einer Bestellung zurück
        /// </summary>
        /// <param name="orderItemId">Id des Artikels in der Bestellung</param>
        /// <returns>Pin oder null, wenn nicht gefunden</returns>
        Task<Pin> GetByOrderItemAsync(long orderItemId);

        /// <summary>
        /// Setzen des Status von Pins nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Pins</returns>
        Task<int> SetStatusByOrderAsync(long orderId, PinStatus status);

        /// <summary>
        /// Setzen des Bezahlstatus von Pins nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Pins</returns>
        Task<int> SetPaymentStatusByOrderAsync(long orderId, PaymentStatus status);

        /// <summary>
        /// Starten von gebuchten Pins wenn diese das Start-Datum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestartete Pins</returns>
        Task<int> StartBookedAsnyc();

        /// <summary>
        /// Stoppen von abgelaufenen Pins wenn diese das Enddatum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestoppte Pins</returns>
        Task<int> StopRunningAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Bestellungen realisiert
    /// </summary>
    public interface IOrderService : IService<Order>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Bestellungen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="includeDeleted">Gelöschte Daten inkludieren</param>
        /// <returns>List betroffener Bestellungen</returns>
        IQueryable<Order> Filter(string filter, bool includeDeleted);

        /// <summary>
        /// Gibt eine gefilterte Liste von Bestellungen für einen Kunden zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="includeDeleted">Gelöschte Daten inkludieren</param>
        /// <returns>List betroffener Bestellungen</returns>
        IQueryable<Order> FilterByCustomer(string filter, long customerId, bool includeDeleted);

        /// <summary>
        /// Gibt eine gefilterte Liste von Bestellungen für einen App-User zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="appUserId">Id des Hundebesitzers</param>
        /// <param name="includeDeleted">Gelöschte Daten inkludieren</param>
        /// <returns>List betroffener Bestellungen</returns>
        IQueryable<Order> FilterByAppUser(string filter, string appUserId, bool includeDeleted);

        /// <summary>
        /// Erstellen einer Bestellung
        /// </summary>
        /// <returns>Bestellung</returns>
        Order Create();

        /// <summary>
        /// Erstellen einer Bestellung
        /// </summary>
        /// <param name="cart">Warenkorb</param>
        /// <param name="cartItems">Artikel im Warenkorb</param>
        /// <param name="paymentType">Zahlungsart</param>
        /// <param name="paymentStatus">Status der Zahlung</param>
        /// <param name="shipmentType">Art der Zustellung</param>
        /// <param name="shipmentStatus">Versandstatus</param>
        /// <param name="deliveryAddress">Lieferadresse</param>
        /// <param name="billingAddress">Rechnungsadresse</param>
        /// <param name="deliveryAddressIsBilling">Lieferadresse ist auch Rechnungsadresse</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="userName">Benutzer der die Bestellung anlegt</param>
        /// <returns>Bestellung</returns>
        Task<Order> CreateAsync(Cart cart, List<CartItem> cartItems, PaymentType paymentType, PaymentStatus paymentStatus, ShipmentType shipmentType, ShipmentStatus shipmentStatus,
            OrderAddress deliveryAddress, OrderAddress billingAddress, bool deliveryAddressIsBilling, string language, string fallback, string userName);

        /// <summary>
        /// Aktualisieren einer Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung die aktualisiert werden soll</param>
        /// <param name="cart">Warenkorb</param>
        /// <param name="cartItems">Artikel im Warenkorb</param>
        /// <param name="paymentType">Zahlungsart</param>
        /// <param name="paymentStatus">Status der Zahlung</param>
        /// <param name="shipmentType">Art der Zustellung</param>
        /// <param name="shipmentStatus">Versandstatus</param>
        /// <param name="deliveryAddress">Lieferadresse</param>
        /// <param name="billingAddress">Rechnungsadresse</param>
        /// <param name="deliveryAddressIsBilling">Lieferadresse ist auch Rechnungsadresse</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="userName">Benutzer der die Bestellung anlegt</param>
        /// <returns>Bestellung</returns>
        Task<Order> UpdateAsync(long orderId, Cart cart, List<CartItem> cartItems, PaymentType paymentType, PaymentStatus paymentStatus, ShipmentType shipmentType, ShipmentStatus shipmentStatus,
            OrderAddress deliveryAddress, OrderAddress billingAddress, bool deliveryAddressIsBilling, string language, string fallback, string userName);

        /// <summary>
        /// Anlegen eines Artikels für eine Bestellung
        /// </summary>
        /// <returns>Bestellung Artikel</returns>
        OrderItem CreateItem();

        /// <summary>
        /// Gibt einen Artikel in einer Bestellung zurück
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="productId">Id des Artikels</param>
        /// <returns>Artikel in der Bestellung oder null, wenn nicht gefunden</returns>
        Task<OrderItem> GetItemAsync(long orderId, int productId);

        /// <summary>
        /// Gibt eine Liste von Artikel in der Bestellung zurück
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <returns>Liste der Artikel in der Bestellung</returns>
        Task<List<OrderItem>> GetItemsAsync(long orderId);

        /// <summary>
        /// Gibt den nächsten freien Bestell-spezifischen Zähler zurück
        /// </summary>
        /// <returns>Nächste freie Nummer</returns>
        Task<long> GetNextCounterAsync();

        /// <summary>
        /// Gibt die nächste freie Nummer für eine Bestellung als Bestellnummer zurück
        /// </summary>
        /// <returns>EndKunden-Nummer</returns>
        Task<string> GetNextNumberAsync();

        /// <summary>
        /// Löschen einer Bestellung
        /// </summary>
        /// <param name="id">Id der Bestellung</param>
        /// <param name="softDelete">Softdelete anwenden - Daten werden auf gelöscht gesetzt</param>
        /// <returns>Task</returns>
        Task DeleteAsync(long id, bool softDelete);

        /// <summary>
        /// Löschen aller Bestellungen die einem Kunden zugeordnet sind
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="softDelete">Softdelete anwenden - Daten werden auf gelöscht gesetzt</param>
        /// <returns>Task</returns>
        Task DeleteByCustomerAsync(long customerId, bool softDelete);

        /// <summary>
        /// Löschen aller Bestellungen die einem App-User zugeordnet sind
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="softDelete">Softdelete anwenden - Daten werden auf gelöscht gesetzt</param>
        /// <returns>Task</returns>
        Task DeleteByAppUserAsync(string appUserId, bool softDelete);

        /// <summary>
        /// Gibt die Anzahl aller Bestellungen im System zurück
        /// </summary>
        /// <param name="includeDeleted">Gelöschte Daten inkludieren</param>
        /// <returns>Anzahl Bestellungen</returns>
        Task<int> CountOrdersAsync(bool includeDeleted);

        /// <summary>
        /// Gibt die Anzahl der Bestellungen in einem bestimmten Status zurück
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Gelöschte Daten inkludieren</param>
        /// <returns>Anzahl Bestellungen</returns>
        Task<int> CountOrdersAsync(OrderStatus status, bool includeDeleted);

        /// <summary>
        /// Gibt die Anzahl der Bestellungen in einem bestimmten Status für Kunden zurück
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Gelöschte Daten inkludieren</param>
        /// <returns>Anzahl Bestellungen</returns>
        Task<int> CountOrdersByCustomerAsync(long customerId, OrderStatus status, bool includeDeleted);

        /// <summary>
        /// Gibt die Anzahl der Bestellungen in einem bestimmten Status für App-User zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Gelöschte Daten inkludieren</param>
        /// <returns>Anzahl Bestellungen</returns>
        Task<int> CountOrdersByAppUserAsync(string appUserId, OrderStatus status, bool includeDeleted);

        /// <summary>
        /// Setzt die ItemId für einen Artikel einer Bestellung auf null, wenn der Artikel gelöscht wird
        /// </summary>
        /// <param name="productId">Id des Artikels</param>
        /// <returns>Task</returns>
        Task ResetProductForOrderItemAsync(int productId);

        /// <summary>
        /// Gibt eine Bestellung anhand der PayPal-ID zurück
        /// </summary>
        /// <param name="payPalId">PayPal Id der Bestellung</param>
        /// <returns>Order oder null, wenn nicht gefunden</returns>
        Task<Order> GetByPayPalIdAsync(string payPalId);

        /// <summary>
        /// Gibt eine Bestellung anhand der Unique-ID zurück
        /// </summary>
        /// <param name="uniqueId">Unique Id der Bestellung</param>
        /// <returns>Order oder null, wenn nicht gefunden</returns>
        Task<Order> GetByUniqueIdAsync(Guid uniqueId);

        /// <summary>
        /// Gibt eine Bestellung anhand Bestellnummer zurück
        /// </summary>
        /// <param name="orderNumber">Bestellnummer</param>
        /// <returns>Order oder null, wenn nicht gefunden</returns>
        Task<Order> GetByOrderNumberAsync(string orderNumber);

        /// <summary>
        /// Setzt den "Versendet" Status für Bestellungen die via Klarna bezahlt wurden und welche keine physischen Produkte beinhalten!
        /// </summary>
        /// <returns>Task</returns>
        Task SetShipmentForKlarnaDigitalOnlyAsync();

        /// <summary>
        /// Gibt eine Liste aller Klarna-Bestellungen zurück, für welche an Klarna der "versendet" Status gesendet werden soll
        /// </summary>
        /// <returns>Liste Bestellungen</returns>
        Task<List<Order>> GetOrdersKlarnaToShipAsync();

        /// <summary>
        /// Gibt zurück ob eine Bestellung nur digitale Produkte beinhaltet
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <returns>true wenn nur digital, false sonst</returns>
        Task<bool> IsDigitaglOnlyAsync(long orderId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Rechnungen ermöglicht
    /// </summary>
    public interface IInvoiceService : IService<Invoice>
    {
        /// <summary>
        /// Erstellen einer Rechnung
        /// </summary>
        /// <returns>Bestellung</returns>
        Invoice Create();

        /// <summary>
        /// Erstellen einer Rechnung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <returns>Bestellung</returns>
        Task<Invoice> CreateAsync(long orderId);

        /// <summary>
        /// Gibt eine Rechnung basierend auf der Bestellung zurück
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <returns></returns>
        Task<Invoice> GetByOrderAsync(long orderId);

        /// <summary>
        /// Gibt den nächsten freien Rechnungs-spezifischen Zähler zurück
        /// </summary>
        /// <returns>Nächste freie Nummer</returns>
        Task<long> GetNextCounterAsync();

        /// <summary>
        /// Gibt die nächste freie Nummer für eine Rechnung als Rechnungsnummer zurück
        /// </summary>
        /// <returns>EndKunden-Nummer</returns>
        Task<string> GetNextNumberAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Gutschriften ermöglicht
    /// </summary>
    public interface ICreditNoteService : IService<CreditNote>
    {
        /// <summary>
        /// Erstellen einer Gutschrift
        /// </summary>
        /// <returns>Gutschrift</returns>
        CreditNote Create();

        /// <summary>
        /// Erstellen einer Gutschrift
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="invoiceNumber">Rechnungsnummer</param>
        /// <returns>Gutschrift</returns>
        Task<CreditNote> CreateAsync(long orderId, string invoiceNumber);

        /// <summary>
        /// Gibt eine Gutschrift basierend auf der Bestellung zurück
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <returns>Gutschrift</returns>
        Task<CreditNote> GetByOrderAsync(long orderId);

        /// <summary>
        /// Gibt den nächsten freien Gutschrift-spezifischen Zähler zurück
        /// </summary>
        /// <returns>Nächste freie Nummer</returns>
        Task<long> GetNextCounterAsync();

        /// <summary>
        /// Gibt die nächste freie Nummer für eine Gutschrift als Gutschriftennummer zurück
        /// </summary>
        /// <returns>Gutschrift-Nummer</returns>
        Task<string> GetNextNumberAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Hunderassen realisiert
    /// </summary>
    public interface IDogRaceService : IService<DogRace>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hunderassen</returns>
        IQueryable<DogRace> Filter(string filter);

        /// <summary>
        /// Erstellen einer Hunderasse
        /// </summary>
        /// <returns>Hunderasse</returns>
        DogRace Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hunderassen</returns>
        Task<List<DogRace>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>List betroffener Hunderassen</returns>
        Task<List<DogRaceWithNames>> SearchWithNamesAsync(string filter, string language, string fallback);

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Hunderassen</returns>
        IQueryable<DogRaceWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Hunderassen zurück, welche nach dem glieferten Datum geändert wurden.
        /// Wird kein Datum angegeben, werden alle zurückgegeben.
        /// </summary>
        /// <param name="lastUpdate">Letztes Update oder null wenn noch keines</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste von Hunderassen</returns>
        Task<List<DogRaceWithNames>> GetForSyncAsync(DateTimeOffset? lastUpdate, string language, string fallback);

        /// <summary>
        /// Gibt eine Hunderasse mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="id">Id der Hunderasse</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Hunderasse oder null, wenn nicht gefunden</returns>
        Task<DogRaceWithNames> GetWithNamesAsync(string id, string language, string fallback);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Hunden realisiert
    /// </summary>
    public interface IDogService : IService<Dog>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Hunden zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hunde</returns>
        IQueryable<Dog> Filter(string filter);

        /// <summary>
        /// Erstellen eines Hunden
        /// </summary>
        /// <returns>Kunde</returns>
        Dog Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunden zurück. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hunde</returns>
        Task<List<Dog>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunden mit Namen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>List betroffener Hunde</returns>
        IQueryable<DogWithNames> FilterWithNames(string filter, string language, string fallback);

        /// <summary>
        /// Gibt die nächste freie Nummer für einen Hund zurück
        /// </summary>
        /// <returns>Hunde-Nummer</returns>
        Task<string> GetNextNumberAsync();

        /// <summary>
        /// Zurücksetzen der Rasse auf null
        /// </summary>
        /// <param name="dogRaceId">Id der Hunderasse</param>
        /// <returns>Anzahl zurückgesetzte Hunde</returns>
        Task<int> ResetDogRaceAsync(string dogRaceId);

        /// <summary>
        /// Gibt eine Liste der Hunde eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der Hunde</returns>
        Task<List<Dog>> GetDogsAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt einen hunde mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="dogId">Id des Hundes</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte auch abgefragt werden - für historische Korrektheit</param>
        /// <returns>Hund oder null, wenn nicht gefunden</returns>
        Task<DogWithNames> GetWithNamesAsync(string dogId, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt alle Hunde mit Namen aufgelöst für einen hundebesitzer zurück
        /// </summary>
        /// <param name="ownerId">Id des Hundebesitzers</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Hund oder null, wenn nicht gefunden</returns>
        Task<List<DogWithNames>> GetWithNamesOwnerAsync(string ownerId, string language, string fallback);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Kategorien für News realisiert
    /// </summary>
    public interface INewsCategoryService : IService<NewsCategory>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Kategorien zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kategorien</returns>
        IQueryable<NewsCategory> Filter(string filter);

        /// <summary>
        /// Erstellen einer Kategorie
        /// </summary>
        /// <returns>Kategorie</returns>
        NewsCategory Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Kategorien zurück. Sucht nur im Titel
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kategorien</returns>
        Task<List<NewsCategory>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Kategorien mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Kategorien</returns>
        IQueryable<NewsCategoryWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Kategorien zurück, welche nach dem glieferten Datum geändert wurden.
        /// Wird kein Datum angegeben, werden alle zurückgegeben.
        /// Es werden alle Kategorien zurückgegeben - egal ob on- oder offline.
        /// </summary>
        /// <param name="lastUpdate">Letztes Update oder null wenn noch keines</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste von Kategorien</returns>
        Task<List<NewsCategoryWithNames>> GetForSyncAsync(DateTimeOffset? lastUpdate, string language, string fallback);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von News realisiert
    /// </summary>
    public interface INewsService : IService<News>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von News zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener News</returns>
        IQueryable<News> Filter(string filter);

        /// <summary>
        /// Erstellen einer News
        /// </summary>
        /// <returns>News</returns>
        News Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von News zurück. Sucht nur im Titel
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener News</returns>
        Task<List<News>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von News mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener News</returns>
        IQueryable<NewsWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine gefilterte Liste von News mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="states">Liste nach Bundesländern nach Filter</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="countries">Liste von Ländern nach Filter</param>
        /// <returns>Liste betroffener News</returns>
        IQueryable<NewsWithNames> FilterWithNames(string filter, List<string>countries, List<string> states, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von News-Meldungen für die App zurück. Es werden nur laufende News berücksichtigt
        /// </summary>
        /// <param name="visibility">Sichtbar für wen? Wird adaptiert!</param>
        /// <param name="categoryId">Gewünschte Kategorie oder leer wenn alle</param>
        /// <param name="country">Land</param>
        /// <param name="state">Bundesland</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste passender News</returns>
        Task<(int total, List<NewsWithNames> list)> GetForAppAsync(NewsVisibility visibility, string categoryId, string country, string state, double? lat, double? lng, string language, string fallback, int skip, int take);

        /// <summary>
        /// Gibt eine News mit Sprachen aufgelöst zurück
        /// </summary>
        /// <param name="newsId">Id der News</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>News mit Namen aufgelöst</returns>
        Task<NewsWithNames> GetWithNamesAsync(long newsId, string language, string fallback);

        /// <summary>
        /// Starten von freigegebenen News wenn diese das Start-Datum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestartete News</returns>
        Task<int> StartApprovedAsnyc();

        /// <summary>
        /// Stoppen von abgelaufenen News wenn diese das Enddatum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestoppte News</returns>
        Task<int> StopRunningAsync();
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service die Verwaltung von Relationen zwischen AppUsern ermöglicht
    /// </summary>
    public interface IAppUserRelationService : IService<AppUserRelation>
    {
        /// <summary>
        /// Fügt eine Relation hinzu wenn diese nicht bereits existiert.
        /// Dabei werden beide Richtungen geprüft.
        /// </summary>
        /// <param name="leftId">Id der ersten Entität</param>
        /// <param name="rightId">Id der zweiten Entität</param>
        /// <param name="userName">Benutzer der die Änderung vorgenommen hat</param>
        /// <returns>Neue Relation oder gefundene Relation</returns>
        Task<AppUserRelation> AddIfNotExistsAsync(string leftId, string rightId, string userName);

        /// <summary>
        /// Setzen einer Relation auf gelöscht - einseitig.
        /// Für den Initiator wird "gelöscht" gesetzt.
        /// Der Initiator wird dabei aber in Left und Right gesucht.
        /// </summary>
        /// <param name="initiatorId">Id des Initiators</param>
        /// <param name="otherId">Id der anderen Entität</param>
        /// <param name="userName">Benutzer der die Änderung vorgenommen hat</param>
        /// <returns>true wenn auf gelöscht gesetzt, false sonst</returns>
        Task<bool> DeleteAsync(string initiatorId, string otherId, string userName);

        /// <summary>
        /// Gibt eine Liste von Relationszielen zurück, zu welcher der Initiator eine Beziehung hat
        /// </summary>
        /// <param name="initiatorId">Id des Initiators</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste von Relationszielen</returns>
        Task<List<AppUserRelationTarget>> GetRelations(string initiatorId, bool includeDeleted = false);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Konversationen und Nachrichten realisiert
    /// </summary>
    public interface IMessageService : IService<Message>
    {
        /// <summary>
        /// Gibt eine Liste der Konversationen eines Benutzers zurück
        /// </summary>
        /// <param name="senderId">Id des Senders</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der Konversationen</returns>
        Task<List<Conversation>> GetConversationsAsync(string senderId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine Liste der Konversationen mit Namen aufgelöst eines Benutzers zurück
        /// </summary>
        /// <param name="senderId">Id des Senders</param>
        /// <returns>Liste der Konversationen</returns>
        Task<List<ConversationWithNames>> GetConversationsWithNamesAsync(string senderId);

        /// <summary>
        /// Gibt eine Konversation anhand der Teilnehmer zurück
        /// </summary>
        /// <param name="senderId">Id des Senders</param>
        /// <param name="receiverId">Id des Empfängers</param>
        /// <returns>Konversation oder null wenn nicht gefunden</returns>
        Task<Conversation> GetConversationAsync(string senderId, string receiverId);

        /// <summary>
        /// Gibt eine gefilterte Liste von Konversationen mit Namen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Konversationen</returns>
        IQueryable<ConversationWithNames> FilterConversationsWithNames(string filter);

        /// <summary>
        /// Hinzufügen einer Konversation
        /// </summary>
        /// <param name="senderId">Id des Senders</param>
        /// <param name="receiverId">Id des Empfängers</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>Konversation</returns>
        Task<Conversation> AddConversationAsync(string senderId, string receiverId, string userName);

        /// <summary>
        /// Hinzufügen einer Konversation
        /// </summary>
        /// <param name="id">Id des Konversation</param>
        /// <param name="senderId">Id des Senders</param>
        /// <param name="receiverId">Id des Empfängers</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>Konversation</returns>
        Task<Conversation> AddConversationAsync(string id, string senderId, string receiverId, string userName);

        /// <summary>
        /// Entfernen einer Konversation
        /// </summary>
        /// <param name="id">Id der Konversation</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        Task<bool> RemoveConversationAsync(string id, string userName);

        /// <summary>
        /// Entfernen einer Konversation nach AppUser
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Anzahl Konversationen</returns>
        Task<int> RemoveConversationByAppUserAsync(string appUserId);

        /// <summary>
        /// Gibt eine Liste noch nicht zugestellter Nachrichten für einen Benutzer zurück.
        /// </summary>
        /// <param name="senderId">Id des Users - wird als Receiver gesucht</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste nicht erhaltener Nachrichten</returns>
        Task<List<Message>> GetMessagesAsync(string senderId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine Liste noch nicht zugestellter Nachrichten in einer Konversation für einen Benutzer zurück.
        /// </summary>
        /// <param name="senderId">Id des Users - wird als Receiver gesucht</param>
        /// <param name="conversationId">Id der Konversation</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste nicht erhaltener Nachrichten</returns>
        Task<List<Message>> GetMessagesAsync(string senderId, string conversationId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Berstätigen des Erhaltes von Nachrichten für einen Benutzer. Alle die älter als das UpdateDatum sind werden gelöscht
        /// </summary>
        /// <param name="senderId">Id des Users - wird als Receiver gesucht</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> ConfirmMessagesAsync(string senderId, DateTimeOffset lastUpdate, string userName);

        /// <summary>
        /// Berstätigen des Erhaltes von Nachrichten für eine Konversation für einen Benutzer. Alle die älter als das UpdateDatum sind werden gelöscht
        /// </summary>
        /// <param name="senderId">Id des Users - wird als Receiver gesucht</param>
        /// <param name="conversationId">Id der Konversation</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> ConfirmMessagesAsync(string senderId, string conversationId, DateTimeOffset lastUpdate, string userName);

        /// <summary>
        /// Hinzufügen einer Nachricht
        /// </summary>
        /// <param name="message">Nachricht</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>Angelegte Nachricht</returns>
        Task<Message> AddMessageAsync(Message message, string userName);

        /// <summary>
        /// Neusetzen des UpdatedAt Datums falls sich das foto eines Benutzers geändert hat
        /// </summary>
        /// <param name="appUserId"></param>
        /// <param name="updatedAt"></param>
        /// <param name="userName"></param>
        /// <returns></returns>
        Task<int> SetUpdatedAtAsync(string appUserId, DateTimeOffset updatedAt, string userName);

        /// <summary>
        /// Gibt die Anzahl der noch nicht gelesenen Nachrichten für einen Benutzer zurück
        /// </summary>
        /// <param name="receiverId">Id des Empfängers</param>
        /// <param name="conversationId">Id der Konversation</param>
        /// <returns>Anzahl ungelesene Nachrichten</returns>
        Task<int> CountOpenMessagesAsync(string receiverId, string conversationId);

        /// <summary>
        /// Entfernt Nachrichten die in einem bestimmten Zeitraum nicht gelesen wurden
        /// </summary>
        /// <param name="olderThanDate">Nachricht muss älter als dieses Datum sein</param>
        /// <returns>Anzahl gelöschte Nachrichten</returns>
        Task<int> RemoveUnreadMessagesAsync(DateTimeOffset olderThanDate);

        /// <summary>
        /// Entfernt Nachrichten-Kopien die alter als ein Datum sind
        /// </summary>
        /// <param name="olderThanDate">Nachricht muss älter als dieses Datum sein</param>
        /// <returns>Anzahl gelöschte Nachrichten</returns>
        Task<int> RemoveMessageCopiesAsync(DateTimeOffset olderThanDate);

        /// <summary>
        /// Gibt die Nachrichten-Kopien einer Konversation zurück
        /// </summary>
        /// <param name="conversationId">Id der Konversation</param>
        /// <returns>Liste nicht erhaltener Nachrichten</returns>
        Task<List<MessageCopy>> GetMessageCopiesAsync(string conversationId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Inhalts-Seiten ermöglicht
    /// </summary>
    public interface IPageService : IService<Page>
    {
        /// <summary>
        /// Erstellen einer Seite
        /// </summary>
        /// <returns></returns>
        Page Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Seiten zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste betroffener Seiten</returns>
        IQueryable<PageWithNames> FilterWithNames(string filter, string language, string fallback);

        /// <summary>
        /// Prüfen ob ein Code noch verfügbar ist
        /// </summary>
        /// <param name="code">Zu prüfender Code</param>
        /// <param name="id">Id die ausgenommen werden soll</param>
        /// <returns>true wenn verfügbar, false sonst</returns>
        Task<bool> IsCodeAvailableAsync(string code, int id);

        /// <summary>
        /// Gibt eine Text-Seite in gewünschter Sprache zurück
        /// </summary>
        /// <param name="code">code der Seite</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Seite oder null, wenn nicht gefunden</returns>
        Task<PageWithNames> GetwithNamesAsync(string code, string language, string fallback);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von öffentlichen Anfragen ermöglicht
    /// </summary>
    public interface IPublicWalkRequestService : IService<PublicWalkRequest>
    {
        /// <summary>
        /// Erstellen einer öffentlichen Anfrage
        /// </summary>
        /// <returns></returns>
        PublicWalkRequest Create();

        /// <summary>
        /// Gibt eine Liste der öffentlichen Anfragen eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<PublicWalkRequest>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt die anzahl öffentlicher Anfragen eines AppUsers zurück
        /// </summary>
        /// <param name="appUserId">AppUserId</param>
        /// <returns>Anzahl öffentliche Anfragen</returns>
        Task<int> CountAsync(string appUserId);

        /// <summary>
        /// Abfrage der öffentlichen Anfragen eines AppUsers "Latest"
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="take">Wie viele Datensätze</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<PublicWalkRequestWithNames>> GetLatestAsync(string appUserId, int take);

        /// <summary>
        /// Gibt eine Liste von eigenen öffentlichen Anfragen für die App zurück.
        /// </summary>
        /// <param name="ignoreId">App-User Id die ignoriert werden soll (dogOwnerId)</param>
        /// <param name="dogOwnerId">Optional: Id des AppUsers der die Anfragen erstellt hat</param>
        /// <param name="dogWalkerId">Optional: Id des DogWalkers</param>
        /// <param name="status">Gesuchert Status. Alle wenn NULL</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste passender Anfragen</returns>
        Task<(int total, List<PublicWalkRequestWithNames> list)> GetAsync(string ignoreId, string dogOwnerId, string dogWalkerId, PublicWalkRequestStatus? status, List<DynamicSortOrder> sortList, double lat, double lng, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von eigenen öffentlichen Anfragen für die App zurück.
        /// </summary>
        /// <param name="ignoreId">App-User Id die ignoriert werden soll (dogOwnerId)</param>
        /// <param name="dogOwnerId">Optional: Id des AppUsers der die Anfragen erstellt hat</param>
        /// <param name="dogWalkerId">Optional: Id des DogWalkers</param>
        /// <param name="status">Gesuchert Status. Alle wenn NULL</param>
        /// <param name="minPrice">Mindest-Preis</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <param name="maxRadius">Maximaler Radius</param>
        /// <param name="type">Typ der öffentlichen Anfrage, Alle wenn NULL</param>
        /// <returns>Liste passender Anfragen</returns>
        Task<(int total, List<PublicWalkRequestWithNames> list)> GetAsync(string ignoreId, string dogOwnerId, string dogWalkerId, PublicWalkRequestStatus? status, double maxRadius, PublicWalkRequestType? type, decimal minPrice, List<DynamicSortOrder> sortList, double lat, double lng, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von eigenen öffentlichen Anfragen für die App zurück. Mit dem Antwort-Status für einen DogWalker
        /// </summary>
        /// <param name="ignoreId">App-User Id die ignoriert werden soll (dogOwnerId)</param>
        /// <param name="dogOwnerId">Optional: Id des AppUsers der die Anfragen erstellt hat</param>
        /// <param name="dogWalkerId">Optional: Id des DogWalkers</param>
        /// <param name="status">Gesuchert Status. Alle wenn NULL</param>
        /// <param name="mustHaveResponse">es muss eine Antwort vorhanden sein</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="includeBlockedAndLocked">Sollten blockierte unnd/oder gesperrte Benutzer in die Liste eingefügt werden?</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <param name="targetDogWalkerId">Id des Dogwalkers für welchen die Liste aufbereitet werden soll</param>
        /// <param name="responseStatus">Gesuchter Status oder aller wenn null</param>
        /// <returns>Liste passender Anfragen</returns>
        Task<(int total, List<PublicWalkRequestWithNamesAndResponseStatus> list)> GetWithResponseStatusAsync(string ignoreId, string dogOwnerId, string dogWalkerId, PublicWalkRequestStatus? status, string targetDogWalkerId, PublicWalkResponseStatus? responseStatus, bool mustHaveResponse, List<DynamicSortOrder> sortList, double lat, double lng, bool includeBlockedAndLocked, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von eigenen öffentlichen Anfragen für die App zurück. Mit dem Antwort-Status für einen DogWalker
        /// </summary>
        /// <param name="ignoreId">App-User Id die ignoriert werden soll (dogOwnerId)</param>
        /// <param name="dogOwnerId">Optional: Id des AppUsers der die Anfragen erstellt hat</param>
        /// <param name="dogWalkerId">Optional: Id des DogWalkers</param>
        /// <param name="status">Gesuchert Status. Alle wenn null</param>
        /// <param name="searchText">Suchtext für Suche in Hundename, OwnerName oder Stadt</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="includeBlockedAndLocked">Sollten blockierte unnd/oder gesperrte Benutzer in die Liste eingefügt werden?</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <param name="targetDogWalkerId">Id des Dogwalkers für welchen die Liste aufbereitet werden soll</param>
        /// <param name="responseStatus">Gesuchter Status oder alle wenn null</param>
        /// <param name="maxRadius">Maximaler Radius</param>
        /// <param name="mustHaveResponse">es muss eine Antwort vorhanden sein</param>
        /// <param name="type">Typ der öffentlichen Anfrage, oder alle wenn NULL</param>
        /// <param name="minPrice">Mindest-Preis</param>
        /// <returns>Liste passender Anfragen</returns>
        Task<(int total, List<PublicWalkRequestWithNamesAndResponseStatus> list)> GetWithResponseStatusAsync(string ignoreId, string dogOwnerId, string dogWalkerId, PublicWalkRequestStatus? status, string targetDogWalkerId, PublicWalkResponseStatus? responseStatus, double maxRadius, PublicWalkRequestType? type, decimal minPrice, bool mustHaveResponse, string searchText, List<DynamicSortOrder> sortList, double lat, double lng, bool includeBlockedAndLocked, int skip, int take);

        /// <summary>
        /// Gibt eine öffentliche Ausschreibung mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="id">ID der Ausschreibung</param>
        /// <returns>öffentliche Ausschreibung oder null, wenn nicht gefunden</returns>
        Task<PublicWalkRequestWithNames> GetWithNamesAsync(string id);

        /// <summary>
        /// Setzt öffentliche Anfragen auf abgelaufen, wenn  diese nicht angenommen oder storniert wurden
        /// </summary>
        /// <param name="date">Datum für Prüfung</param>
        /// <returns>Anzahl timed out</returns>
        Task<int> SetTimedOutAsync(DateTimeOffset date);

        /// <summary>
        /// Zurücksetzen einer öffentlichen Anfrage
        /// </summary>
        /// <param name="id">Id der öffentlichen Anfrage</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> ResetAsync(string id);

        /// <summary>
        /// Gibt eine Liste der offenen Anfragen für einen Hundebesitzer in einem gewählten Status zurück
        /// </summary>
        /// <param name="dogOwnerId">Id des Hundebesitzers</param>
        /// <param name="status">Gesuchter Status</param>
        /// <returns></returns>
        Task<List<PublicWalkRequest>> GetByStatusAsync(string dogOwnerId, PublicWalkRequestStatus status);

        /// <summary>
        /// Gibt eine gefilterte Liste von öffentlichen Anfragen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener öffentlicher Anfragen</returns>
        IQueryable<PublicWalkRequestWithNames> FilterPublicWalkRequestsWithNames(string filter, bool includeDeleted);

        #region Notifications

        /// <summary>
        /// Erstellt einen Eintrag für die Benachrichtigung einer neuen öffentlichen Anfrage
        /// </summary>
        /// <param name="publicWalkRequestId">Id der öffentlichen Anfrage</param>
        /// <param name="dogOwnerId">Id des Hundebesitzers - AppUserId</param>
        /// <param name="pickupAddress">Abholadresse</param>
        /// <param name="location">GEO-Koordinaten</param>
        /// <returns>PublicWalkRequestNotification</returns>
        PublicWalkRequestNotification CreateNotification(string publicWalkRequestId, string dogOwnerId, Address pickupAddress, Point location);

        /// <summary>
        /// Hinzufügen einer Benachrichtigung
        /// </summary>
        /// <param name="publicWalkRequestNotification">Benachrichtigungs-Objekt</param>
        void AddNotification(PublicWalkRequestNotification publicWalkRequestNotification);

        /// <summary>
        /// Gibt eine Liste von zu sendenden Benachrichtigungen zurück
        /// </summary>
        /// <returns>Liste zu sendende Benachrichtigungen</returns>
        Task<List<PublicWalkRequestNotification>> GetNotificationsToSendAsync();

        /// <summary>
        /// Zählt wie viele öffenltiche Anfragen in einem bestimmten Zeitraum durch einen Benutzer erstellt wurden
        /// </summary>
        /// <param name="startDate">Start-Datum</param>
        /// <param name="endDate">End-Datum</param>
        /// <param name="dogOwnerId">Id des Hundebesitzers</param>
        /// <param name="maxStatus">Max Status der Ausschreibung</param>
        /// <returns>Anzahl öffentliche Anfragen</returns>
        Task<int> CountByCreationDateAsync(DateTimeOffset startDate, DateTimeOffset endDate, string dogOwnerId, PublicWalkRequestStatus maxStatus);

        #endregion
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Antworten auf öffentlichen Anfragen ermöglicht
    /// </summary>
    public interface IPublicWalkResponseService : IService<PublicWalkResponse>
    {
        /// <summary>
        /// Erstellen einer Antwort auf eine öffentlichen Anfrage
        /// </summary>
        /// <returns></returns>
        PublicWalkResponse Create(string publicWalkRequestId);

        /// <summary>
        /// Gibt eine Liste der Antworten auf öffentlichen Anfragen eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der Antworten auf öffentlichen Anfragen</returns>
        Task<List<PublicWalkResponse>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine Antwort eines Walkers auf eine öffentliche Anfrage zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers dem die öffentliche Anfrage gehört</param>
        /// <param name="publicWalkResponseId">Id der Antwort zur öffentlichen Anfrage</param>
        /// <returns>PublicWalkResponse oder null, wenn keine gefunden</returns>
        Task<PublicWalkResponseWithNames> GetWithNamesAsync(string appUserId, string publicWalkResponseId);

        /// <summary>
        /// Gibt eine Antwort eines Walkers auf eine öffentliche Anfrage zurück
        /// </summary>
        /// <param name="dogWalkerId">Id des Walkers</param>
        /// <param name="publicWalkRequestId">Id der öffntlichen Anfrage</param>
        /// <returns>PublicWalkResponse oder null, wenn keine gefunden</returns>
        Task<PublicWalkResponse> GetForWalkerAsync(string dogWalkerId, string publicWalkRequestId);

        /// <summary>
        /// Gibt die Anzahl der Antworten auf eine öffentliche Anfrage zurück
        /// </summary>
        /// <param name="publicWalkRequestId">Id der öffentlichen Anfrage</param>
        /// <returns>Anzahl Antworten</returns>
        Task<int> CountForPublicWalkRequestAsync(string publicWalkRequestId);

        /// <summary>
        /// Gibt eine Liste von Antworten zu einer öffentlichen Anfragen für die App zurück.
        /// </summary>
        /// <param name="appUserId">Id des AppUsers dem die öffentliche Anfrage gehört</param>
        /// <param name="publicRequestId">Id der öffentlichen Anfrage</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste passender antworten</returns>
        Task<(int total, List<PublicWalkResponseWithNames> list)> GetResponsesAsync(string appUserId, string publicRequestId, int skip, int take);

        /// <summary>
        /// Gibt eine Liste aller Antworten zu einer öffentlichen Anfragen zurück.
        /// </summary>
        /// <param name="appUserId">Id des AppUsers dem die öffentliche Anfrage gehört</param>
        /// <param name="publicRequestId">Id der öffentlichen Anfrage</param>
        /// <returns>Liste passender antworten</returns>
        Task<List<PublicWalkResponseWithNames>> GetResponsesAsync(string appUserId, string publicRequestId);

        /// <summary>
        /// Setzen des Closed Status für Angebote die im Warten-Status sind.
        /// Wird verwendet wenn ein Angebot angenommen wurde und man nun den anderen Bewerbern mitteilen muss, dass wer anderes genommen wurde
        /// </summary>
        /// <param name="publicWalkRequestId">Id der öffentlichen Anfrage</param>
        /// <returns>Anzahl geännderte Angebote</returns>
        Task<int> SetCompletedForWaitingAsync(string publicWalkRequestId);

        /// <summary>
        /// Setzen des Open Status für Angebote die im Closed-Status oder akzeptiert Status sind.
        /// Wird verwendet wenn ein angenommenes Angebot nicht bezahlt wurde und ein Reset der öffentlichen Anfrage durchgeführt wird
        /// </summary>
        /// <param name="publicWalkRequestId">Id der öffentlichen Anfrage</param>
        /// <returns>Anzahl geännderte Angebote</returns>
        Task<int> SetOpenForClosedOrAcceptedAsync(string publicWalkRequestId);

        /// <summary>
        /// Stornieren von Angeobten für offene öffentliche Anfragen wenn ein Benutzer gesperrt wurde
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>Anzahl stornierte Angebote</returns>
        Task<int> CancelForLockedAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Walks ermöglicht
    /// </summary>
    public interface IWalkService : IService<Walk>
    {
        /// <summary>
        /// Erstellen eines Walks
        /// </summary>
        /// <returns>Walk</returns>
        Walk Create();

        /// <summary>
        /// Gibt eine Liste der Walks eines Benutzers zurück. Kann Owner und Walker sein
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<Walk>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine gefilterte Liste von Walks zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener öffentlicher Anfragen</returns>
        IQueryable<WalkWithNames> FilterWithNames(string filter, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Walks mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="dogWalkerId">Id des Dogwalkers oder leer wenn nicht für DogWalker</param>
        /// <param name="dogOwnerId">Id des DogOwners oder leer wenn nicht für DogOwner</param>
        /// <param name="date">Datum ab dem gesucht werden soll oder NULL wenn alle</param>
        /// <param name="status">Status des Walks, NULL wenn alle</param>
        /// <param name="serviceType">Service Type, NULL wenn alle</param>
        /// <param name="paymentStatus">Zahlungsstatus, NULL wenn alle</param>
        /// <param name="dogFilter">Optinal: nach HundeID filtern</param>
        /// <param name="walkerFilter">Optional: nach Walkername filtern</param>
        /// <param name="ownerFilter">Optional: nach Ownername filtern</param>
        /// <param name="ignoreCancelled">Stornierte Ignorieren</param>
        /// <param name="forNextWalk">Sollen nur Walks für den nächsten Walk selektiert werden? Dann nur Angenommene oder Laufende</param>
        /// <param name="ignoreRequested">Sollen Walks die noch eine Anfrage sind, ohne Akzeptiert oder Agelehnt ignorniert werden?</param>
        /// <param name="ignoreDeclined">Sollen abgelehnte Walks ignoriert werden?</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<WalkWithNames> list)> GetWithNamesAsync(string dogWalkerId, string dogOwnerId, DateTimeOffset? date, WalkStatus? status, WalkServiceType? serviceType, PaymentStatus? paymentStatus, string dogFilter, string walkerFilter, string ownerFilter, bool ignoreCancelled, bool forNextWalk, bool ignoreRequested, bool ignoreDeclined, List<DynamicSortOrder> sortList, double lat, double lng, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von Walks mit Namen aufgelöst zurück für Walker
        /// Sonderfall hier ist, dass keine Walks mit einem PaymentStatus unter Authorized zurückgibt
        /// </summary>
        /// <param name="dogWalkerId">Id des Dogwalkers oder leer wenn nicht für DogWalker</param>
        /// <param name="dogOwnerId">Id des DogOwners oder leer wenn nicht für DogOwner</param>
        /// <param name="date">Datum ab dem gesucht werden soll oder NULL wenn alle</param>
        /// <param name="status">Status des Walks, NULL wenn alle</param>
        /// <param name="serviceType">Service Type, NULL wenn alle</param>
        /// <param name="paymentStatus">Zahlungsstatus, NULL wenn alle</param>
        /// <param name="dogFilter">Optinal: nach HundeID filtern</param>
        /// <param name="walkerFilter">Optional: nach Walkername filtern</param>
        /// <param name="ownerFilter">Optional: nach Ownername filtern</param>
        /// <param name="ignoreCancelled">Stornierte Ignorieren</param>
        /// <param name="forNextWalk">Sollen nur Walks für den nächsten Walk selektiert werden? Dann nur Angenommene oder Laufende</param>
        /// <param name="ignoreRequested">Sollen Walks die noch eine Anfrage sind, ohne Akzeptiert oder Agelehnt ignorniert werden?</param>
        /// <param name="ignoreDeclined">Sollen abgelehnte Walks ignoriert werden?</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="lat">Optional: Breitengrad</param>
        /// <param name="lng">Optional: Längengrad</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<WalkWithNames> list)> GetWithNamesForWalkerAsync(string dogWalkerId, string dogOwnerId, DateTimeOffset? date, WalkStatus? status, WalkServiceType? serviceType, PaymentStatus? paymentStatus, string dogFilter, string walkerFilter, string ownerFilter, bool ignoreCancelled, bool forNextWalk, bool ignoreRequested, bool ignoreDeclined, List<DynamicSortOrder> sortList, double lat, double lng, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von Walks mit Namen aufgelöst zurück für Hundebesitzer die anstehen, laufen, nicht abgeschlossen sind, nicht gestartet wurden oder zu bezahlen sind
        /// </summary>
        /// <param name="dogOwnerId">Id des Hundebesitzers</param>
        /// <param name="date">Datum ab dem gesucht werden soll oder NULL wenn alle</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<WalkWithNames> list)> GetNextWithNamesForOwnerAsync(string dogOwnerId, DateTimeOffset date, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von Walks mit Namen aufgelöst zurück für Walker die anstehen, laufen, nicht abgeschlossen sind oder nicht gestartet wurden
        /// </summary>
        /// <param name="dogWalkerId">Id des Walkers</param>
        /// <param name="date">Datum ab dem gesucht werden soll oder NULL wenn alle</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<WalkWithNames> list)> GetNextWithNamesForWalkerAsync(string dogWalkerId, DateTimeOffset date, int skip, int take);

        /// <summary>
        /// Gibt einen Walk mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="walkId">Id des Walks</param>
        /// <returns>Walk oder null, wenn nicht gefunden</returns>
        Task<WalkWithNames> GetWalkWithNamesAsync(string walkId);

        /// <summary>
        /// Zurückgeben einer Liste von Walks die einen bestimmten Status haben
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <returns>Liste von Walks</returns>
        Task<List<Walk>> GetByStatusAsync(WalkStatus status);

        /// <summary>
        /// Gibt einen Walk zurück der mit einer öffentlichen Anfrage verknüpft ist
        /// </summary>
        /// <param name="publicWalkRequestId">Id der öffentlichen Anfrage</param>
        /// <returns>Walk oder null, wenn nicht gefunden</returns>
        Task<Walk> GetWalkByPublicRequestAsync(string publicWalkRequestId);

        /// <summary>
        /// Prüft ob ein Walk für einen Zeitraum gebucht werden kann.
        /// Sittings werden dabei ignoriert!
        /// </summary>
        /// <param name="dogWalkerId">Id des dogwalkers</param>
        /// <param name="start">Startdatum</param>
        /// <param name="end">Enddatum</param>
        /// <returns>true wenn verfügbar, false sonst</returns>
        Task<bool> IsWalkPossibleAsync(string dogWalkerId, DateTimeOffset start, DateTimeOffset end);

        /// <summary>
        /// Setzt Walks die im Status "Request" sind auf Cancel.
        /// Wird verwendet wenn eine FIXE buchung gemacht wird und andere noch auf eine Antwort warten.
        /// </summary>
        /// <param name="dogWalkerId">Id des dogwalkers</param>
        /// <param name="start">Startdatum</param>
        /// <param name="end">Enddatum</param>
        /// <returns>Anzahl betroffene Walks</returns>
        Task<int> CancelWalkRequestsAsync(string dogWalkerId, DateTimeOffset start, DateTimeOffset end);

        /// <summary>
        /// Walks stornieren welche im Status Request sind und das Startdatum erreicht wurde
        /// </summary>
        /// <param name="date">Datum für Prüfung</param>
        /// <returns>Anzahl timed out</returns>
        Task<int> CancelTimedOutAsync(DateTimeOffset date);

        /// <summary>
        /// Stornieren von Walks die im Zahlungsstatus Pending sind und länger als X Minuten alt sind
        /// </summary>
        /// <param name="date">Datum für Prüfung</param>
        /// <param name="minutes">Ablaufzeit in Minuten</param>
        /// <returns>Anzahl storniert</returns>
        Task<int> CancelPendingAsync(DateTimeOffset date, int minutes);

        /// <summary>
        /// Abschliessen eines Walks, falls das vergessen wurde
        /// </summary>
        /// <param name="date">Datum für Prüfung</param>
        /// <param name="minutes">Ablaufzeit in Minuten</param>
        /// <returns>Anzahl abgeschlossen</returns>
        Task<int> CompleteAutoAsync(DateTimeOffset date, int minutes);

        /// <summary>
        /// Bestätigen von Walks die im Status Abgeschlossen sind und länger als X Minuten alt sind.
        /// Löst die Überweisung von den Kosten für den Walk vom hundebesitzer an den Dogwalker aus.
        /// </summary>
        /// <param name="date">Datum für Prüfung</param>
        /// <param name="minutes">Ablaufzeit in Minuten</param>
        /// <returns>Anzahl bestätigt</returns>
        Task<int> ConfirmCompletedAsync(DateTimeOffset date, int minutes);

        /// <summary>
        /// Bestätigen von Walks die im Status Abgeschlossen sind und länger als X Minuten alt sind.
        /// Löst die Überweisung von den Kosten für den Walk vom hundebesitzer an den Dogwalker aus.
        /// </summary>
        /// <param name="date">Datum für Prüfung</param>
        /// <param name="minutes">Ablaufzeit in Minuten</param>
        /// <returns>Anzahl bestätigt</returns>
        Task<int> ConfirmCompletedReminderAsync(DateTimeOffset date, int minutes);

        /// <summary>
        /// Storniert Liste von Walks, welche für 2 App-User in Beziehung stehen wenn eine Blockierung stattgefunden hat.
        /// Wird bidirektional gesucht, da nicht immer sichergestellt ist, dass einer Walker und einer Owner ist.
        /// Es werden nur Walks im Status Requested oder Accepted berücksichtigt
        /// </summary>
        /// <param name="blockingAppUserId">Id des App-Users der blockiert hat</param>
        /// <param name="blockedAppUserId">Id des App-Users der blockiert wurde</param>
        /// <returns>Anzahl stornierte Walks</returns>
        Task<int> CancelWalksForBlockAsync(string blockingAppUserId, string blockedAppUserId);

        /// <summary>
        /// Stornieren aller Walks eines Benutzers der gesperrt wurde.
        /// Wird bidirektional gesucht, da nicht immer sichergestellt ist, dass einer Walker und einer Owner ist.
        /// Es werden nur Walks im Status Requested oder Accepted berücksichtigt
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>Anzahl stornierte Walks</returns>
        Task<int> CancelWalksForLockedAsync(string appUserId);

        /// <summary>
        /// Fügt die Verwendung eines Gutscheins zu einem Walk hinzu
        /// </summary>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="voucherId">Id des Gutscheins</param>
        /// <param name="ammount">Verwendeter Gutscheinwert</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> AddVoucherToWalk(string walkId, string voucherId, decimal ammount);

        /// <summary>
        /// Entfernt die Verwendung eines Gutscheins zu einem Walk
        /// </summary>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="voucherId">Id des Gutscheins</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> RemoveVoucherFromWalk(string walkId, string voucherId);

        /// <summary>
        /// Gibt die Anzahl von Walks für einen Dogwalker mit dem Status Bestätigt in einem bestimmten Zeitraum zurück
        /// </summary>
        /// <param name="dogWalkerId">Id des DogWalkers</param>
        /// <param name="startDate">StartDatum</param>
        /// <param name="endDate">Enddatum</param>
        /// <returns>Anzahl Walks</returns>
        Task<int> CountConfirmedByTimeRangeAsync(string dogWalkerId, DateTimeOffset startDate, DateTimeOffset endDate);
    }

    /// <summary>
    /// Schnittstellenbeschreibug für einen Service der die Verwaltung von Walking-Schedules ermöglicht.
    /// Das bedeutet die einstellung an welchen Wochentagen ein Walker zu welchen Zeiten zur Verfügung steht
    /// </summary>
    public interface IWalkingTimeService : IService<WalkingTime>
    {
        /// <summary>
        /// Erstellt eine Walkingtime Einstellung
        /// </summary>
        /// <param name="dogWalkerId">Id des Dogwalkers</param>
        /// <returns>WalkingTime</returns>
        WalkingTime Create(string dogWalkerId);

        /// <summary>
        /// Gibt eine Liste der Walkintimes eines Benutzers für das Syncing mit der App zurück.
        /// </summary>
        /// <param name="dogWalkerId">Id des DogWalkers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<WalkingTime>> GetForSyncAppAsync(string dogWalkerId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine Liste der Walkintimes eines Benutzers zurück.
        /// </summary>
        /// <param name="dogWalkerId">Id des DogWalkers</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<WalkingTime>> GetAllAsync(string dogWalkerId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Ratings ermöglicht
    /// </summary>
    public interface IRatingService : IService<Rating>
    {
        /// <summary>
        /// Erstellen eines Ratings
        /// </summary>
        /// <returns>Rating</returns>
        Rating Create();

        /// <summary>
        /// Erstellen eines Ratings
        /// </summary>
        /// <param name="fromId">Id der Rating Quelle</param>
        /// <param name="fromType">Typ der Rating Quelle</param>
        /// <param name="targetId">Id des Ziels des Ratings</param>
        /// <param name="targetType">Typ des Rating Ziels</param>
        /// <param name="points">Vergebene Punkte</param>
        /// <param name="info">Zusatzinfo zum Rating</param>
        /// <returns>Rating</returns>
        Rating Create(string fromId, AppUserType fromType, string targetId, RatingTarget targetType, decimal points, string info);

        /// <summary>
        /// Gibt eine Liste der Ratings eines Benutzers zurück. Kann Owner und Walker sein
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<Rating>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt ein Rating basierend auf Abfragekriterien zurück
        /// </summary>
        /// <param name="fromId">Id der Rating Quelle</param>
        /// <param name="fromType">Typ der Rating Quelle</param>
        /// <param name="targetId">Id des Ziels des Ratings</param>
        /// <param name="targetType">Typ des Rating Ziels</param>
        /// <returns>Rating wenn gefunden, null sonst</returns>
        Task<Rating> GetRatingExAsync(string fromId, AppUserType fromType, string targetId, RatingTarget targetType);

        /// <summary>
        /// Neu berechnen der Ratings-Statistics für ein Ziel
        /// </summary>
        /// <param name="targetId">Id des Ziels des Ratings</param>
        /// <param name="targetType">Typ des Rating Ziels</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> UpdateRatingStatisticsAsync(string targetId, RatingTarget targetType);

        /// <summary>
        /// Gibt an ob ein Bewerter ein Ziel bereits bewertet hat
        /// </summary>
        /// <param name="fromId">Id der Rating Quelle</param>
        /// <param name="fromType">Typ der Rating Quelle</param>
        /// <param name="targetId">Id des Ziels des Ratings</param>
        /// <param name="targetType">Typ des Rating Ziels</param>
        /// <returns>true wenn bereits bewertet, false sonst</returns>
        Task<bool> HasRatedAsync(string fromId, AppUserType fromType, string targetId, RatingTarget targetType);

        /// <summary>
        /// Gibt zurück ob ein Bewerter ein Ziel bewerten darf.
        /// z.B. ein Walker darf einen hund nur bewerten, wenn mindestens ein Walk mit dem hund stattgefunden hat.
        /// Ein Owner darf einen Walker nur bewerten, wenn dieser mindestens einen Walk für den Owen gemacht hat usw.
        /// </summary>
        /// <param name="fromId">Id der Rating Quelle</param>
        /// <param name="fromType">Typ der Rating Quelle</param>
        /// <param name="targetId">Id des Ziels des Ratings</param>
        /// <param name="targetType">Typ des Rating Ziels</param>
        /// <returns>true wenn eine Bewertung stattfinden darf, false sonst</returns>
        Task<bool> CanRateAsync(string fromId, AppUserType fromType, string targetId, RatingTarget targetType);

        /// <summary>
        /// Alle Ratings eines AppUsers und für einen AppUser löschen
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Liste von Rating-Ziele deren Statistik aktualisiert werden muss</returns>
        Task<List<Tuple<string, RatingTarget>>> DeleteAllForAppUserAsync(string appUserId);

        /// <summary>
        /// Gibt eine Liste von Ratings mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="fromId">Id der Rating Quelle</param>
        /// <param name="fromType">Typ der Rating Quelle</param>
        /// <param name="targetId">Id des Ziels des Ratings</param>
        /// <param name="targetType">Typ des Rating Ziels</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<RatingWithNames> list)> GetWithNamesAsync(string fromId, AppUserType? fromType, string targetId, RatingTarget? targetType, List<DynamicSortOrder> sortList, int skip, int take);

        /// <summary>
        /// Gibt eine Liste von Ratings mit Namen aufgelöst und mit lock und block Info zurück
        /// </summary>
        /// <param name="blockingAppUserId">Id des Benutzers der abfrägt und für den Blocking geprüft wird</param>
        /// <param name="fromId">Id der Rating Quelle</param>
        /// <param name="fromType">Typ der Rating Quelle</param>
        /// <param name="targetId">Id des Ziels des Ratings</param>
        /// <param name="targetType">Typ des Rating Ziels</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<RatingWithNamesEx> list)> GetWithNamesExAsync(string blockingAppUserId, string fromId, AppUserType? fromType, string targetId, RatingTarget? targetType, List<DynamicSortOrder> sortList, int skip, int take);

        /// <summary>
        /// Gibt ein Rating mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="ratingId">Id des Ratings</param>
        /// <returns>Rating oder null, wenn nicht gefunden</returns>
        Task<RatingWithNames> GetWithNamesAsync(string ratingId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Feedbacks aus der App ermöglicht
    /// </summary>
    public interface IAppFeedbackService : IService<AppFeedback>
    {
        /// <summary>
        /// Erstellen eines Feedback
        /// </summary>
        /// <returns>AppFeedback</returns>
        AppFeedback Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Feedback zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Feedbacks</returns>
        IQueryable<AppFeedback> Filter(string filter);

        /// <summary>
        /// Gibt die Anzahl von Feedbacks in einem bestimmten Status zurück
        /// </summary>
        /// <param name="status">Gewünschter Status</param>
        /// <returns>Anzahl Feedbacks im Status</returns>
        Task<int> CountAsync(AppFeedbackStatus status);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Favoriten ermöglicht
    /// </summary>
    public interface IFavouriteService : IService<Favourite>
    {
        /// <summary>
        /// Erstellen eines Favoriten
        /// </summary>
        /// <returns>Rating</returns>
        Favourite Create();

        /// <summary>
        /// Erstellen eines Favoriten
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="key">Id des verknüpften Objekts</param>
        /// <param name="table">Typ des verknüpften Objekts</param>
        /// <returns>Rating</returns>
        Favourite Create(string appUserId, string key, string table);

        /// <summary>
        /// Gibt eine Liste der Favoriten eines Benutzers zurück. Kann Owner und Walker sein
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<Favourite>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine Liste der Favoriten eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Liste der Favoriten</returns>
        Task<List<Favourite>> GetForAppUserAsync(string appUserId);

        /// <summary>
        /// Gibt eine Liste der Favoriten eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="table">Typ des Objektes das gesucht wird</param>
        /// <returns>Liste der Favoriten</returns>
        Task<List<Favourite>> GetForAppUserAsync(string appUserId, string table);

		/// <summary>
		/// Alle Favoriten eines AppUsers löschen
		/// </summary>
		/// <param name="appUserId">Id des AppUsers</param>
		/// <returns>Anzahl gelöscht</returns>
		Task<int> DeleteAllForAppUserAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschrigun für einen Service der die Verwaltung von Systemnachrichten ermöglicht
    /// </summary>
    public interface ISystemMessageService : IService<SystemMessage>
    {
        /// <summary>
        /// Erstellen einer Systemnachrichten
        /// </summary>
        /// <returns>Systemnachricht</returns>
        SystemMessage Create();

        /// <summary>
        /// Erstellen einer Systemnachrichten
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des verknüpften Objekts</param>
        /// <param name="table">Typ des verknüpften Objekts</param>
        /// <param name="type">Typ der Systemnachricht</param>
        /// <returns>Systemnachricht</returns>
        SystemMessage Create(string appUserId, AppUserType appUserType, string key, string table, SystemMessageType type);

        /// <summary>
        /// Gibt eine Liste der Systemnachrichten eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der Systemnachricht</returns>
        Task<List<SystemMessage>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Berstätigen des Erhaltes von SystemNachrichten für einen Benutzer. Alle die älter als das UpdateDatum sind werden gelöscht
        /// </summary>
        /// <param name="senderId">Id des Users - wird als Receiver gesucht</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        Task<bool> ConfirmAsync(string senderId, DateTimeOffset lastUpdate, string userName);

        /// <summary>
        /// Entfernen von Systemnachrichten für einen Benutzer wenn diese in der App schon gesehen wurden
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des verknüpften Objekts</param>
        /// <param name="table">Typ des verknüpften Objekts</param>
        /// <param name="created">Datum  - das created Datum der Systemnachricht muss kleiner gleich sein</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>Systemnachricht</returns>
        Task<bool> RemoveAsync(string appUserId, AppUserType appUserType, string key, string table, DateTimeOffset? created, string userName);

        /// <summary>
        /// Hinzufügen eines Systemnachricht
        /// </summary>
        /// <param name="appUserId">Id des Ziels</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des Objekts</param>
        /// <param name="table">Objekttyp</param>
        /// <param name="type">Nachrichten-Typ</param>
        /// <param name="expires">Ablaufdatum</param>
        /// <returns>Task</returns>
        void Add(string appUserId, AppUserType appUserType, string key, string table, SystemMessageType type, DateTimeOffset expires);

        /// <summary>
        /// Hinzufügen einer Systemnachricht als Text. Setzt den Typen automatisch
        /// </summary>
        /// <param name="appUserId">Id des Ziels</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des Objekts</param>
        /// <param name="expires">Ablaufdatum</param>
        /// <param name="message">Nachricht</param>
        /// <returns>Task</returns>
        void Add(string appUserId, AppUserType appUserType, string key, DateTimeOffset expires, string message);

        /// <summary>
        /// Löschen abgelaufener Nachrichten
        /// </summary>
        /// <param name="date">Grenzdatum für Expired</param>
        /// <returns>Anzahl gelöschte Nachrichten</returns>
        Task<int> RemoveExpiredAsync(DateTimeOffset date);

        /// <summary>
        /// Alle Systemnachrichten eines AppUsers löschen
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Anzahl gelöscht</returns>
        Task<int> DeleteAllForAppUserAsync(string appUserId);

		#region SystemMessagesToSend

		/// <summary>
		/// Erstellen einer Systemnachrichten die gesendet werden sollen
		/// </summary>
		/// <returns>Systemnachricht die gesendet werden soll</returns>
		SystemMessageToSend CreateToSend();

        /// <summary>
        /// Gibt eine gefilterte Liste von Systemnachrichten die gesendet werden sollen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Systemnachrichten die gesendet werden sollen</returns>
        IQueryable<SystemMessageToSend> FilterSystemMessagesToSend(string filter);

        /// <summary>
        /// Hinzufügen einer Systemnachricht die gesendet werden soll
        /// </summary>
        /// <param name="item">SystemMessageToSend</param>
        void AddToSend(SystemMessageToSend item);

        /// <summary>
        /// Löschen einer Systemnachricht die gesendet werden soll
        /// </summary>
        /// <param name="item">SystemMessageToSend</param>
        void RemoveToSend(SystemMessageToSend item);

        /// <summary>
        /// Gibt eine Systemnachricht die gesendet werden soll zurück
        /// </summary>
        /// <param name="id">Id der Systemnachricht</param>
        /// <returns>SystemMessageToSend oder null, wenn nicht gefunden</returns>
        Task<SystemMessageToSend> GetToSendAsync(long id);

        /// <summary>
        /// Gibt eine Liste von Systemnachrichten die gesendet werden sollen zurück.
        /// Bereits gesendete oder Nachrichten die kein Versanddatum haben werden nicht zurückgegeben
        /// </summary>
        /// <param name="date">Datum das größer als das Versanddatum sein muss</param>
        /// <returns>Liste Nachrichten zu senden</returns>
        Task<List<SystemMessageToSend>> GetToSendAsync(DateTimeOffset date);

        #endregion
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Devices der App-User ermöglicht
    /// </summary>
    public interface IDeviceService : IService<Device>
    {
	    /// <summary>
	    /// Anlegen oder Aktualisieren eines Devices
	    /// </summary>
	    /// <param name="appUserId">ID des AppUsers</param>
	    /// <param name="installationId">eindeutige InstallationsID</param>
	    /// <param name="platform">Platform (OS)</param>
	    /// <param name="notificationPlatform">Platform (PNS)</param>
	    /// <param name="channel">Token des Users</param>
	    /// <param name="language">Sprache die am Gerät eingestellt ist</param>
	    /// <param name="suppresCommit">Soll Commit untertrückt werden</param>
	    /// <returns>Device</returns>
	    Task<Device> CreateOrUpdateAsync(string appUserId, string installationId, Platform platform, NotificationPlatform notificationPlatform, string channel, string language, bool suppresCommit);

		/// <summary>
		/// Löschen eines Devices eines Benutzers mit einer InstallationsId
		/// </summary>
		/// <param name="appUserId"></param>
		/// <param name="installationId"></param>
		/// <param name="suppresCommit">Soll Commit untertrückt werden</param>
		/// <returns></returns>
		Task<bool> DeleteAsync(string appUserId, string installationId, bool suppresCommit);

        /// <summary>
        /// Gibt eine Liste aller Devices eines App-Users zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Liste von Devices</returns>
	    Task<List<Device>> GetAllAsync(string appUserId);

        /// <summary>
        /// Gibt ein Device für einen App-User zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="installationId">InstallationsId des Devices</param>
        /// <returns>Device oder null, wenn nicht gefunden</returns>
        Task<Device> GetAsycn(string appUserId, string installationId);
	}

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Wallets ermöglicht
    /// </summary>
    public interface IWalletService : IService<Wallet>
    {
		/// <summary>
		/// Erstellen eines Wallets für einen AppUser
		/// </summary>
		/// <param name="appUserId">Id des AppUsers</param>
		/// <param name="walletId">ID des Walltes bei Mangopay</param>
		/// <param name="type">Typ des Wallets</param>
		/// <param name="ownerId">Id des Payment Owners (PaymentId)</param>
		/// <param name="currency">Währung ISO 4217 Code</param>
		/// <param name="description">Beschreibung</param>
		/// <returns>Wallet</returns>
		Wallet Create(string appUserId, string walletId, WalletType type, string ownerId, string currency, string description);

        /// <summary>
        /// Gibt ein Wallet für einen AppUser mit einem Typ zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="type">Typ des Wallets</param>
        /// <returns>Wallet oder null, wenn nicht gefunden</returns>
		Task<Wallet> GetAsync(string appUserId, WalletType type);

        /// <summary>
        /// Gibt eine Liste aller Wallets eines AppUsers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Liste von Wallets</returns>
        Task<List<Wallet>> GetAllAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Transaktionsgebühren ermöglichts
    /// </summary>
    public interface ITransactionFeeService : IService<TransactionFee>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Transaktionsgebühren zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Transaktionsgebühren</returns>
        IQueryable<TransactionFee> Filter(string filter);

        /// <summary>
        /// Erstellen einer Tranksaktionsgebühr
        /// </summary>
        /// <returns>Tranksaktionsgebühr</returns>
        TransactionFee Create();

        /// <summary>
        /// Prüft ob schon eine Einstellung für einen Typ vorhanden ist
        /// </summary>
        /// <param name="payInType">Zahlungsmethode</param>
        /// <returns>true wenn bereits vorhanden, false sonst</returns>
        Task<bool> ExistsAsync(PayInType payInType);

        /// <summary>
        /// Gibt eine Liste von Transaktionsgebühren zurück, die für die Synchronisation benötigt werden
        /// </summary>
        /// <param name="lastUpdate">Letztes Update oder null wenn noch keines</param>
        /// <returns>Liste von Transaktionsgebühren</returns>
        Task<List<TransactionFee>> GetForSyncAsync(DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine gefilterte Liste von GehGassi-Gebühren zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener GehGassi-Gebühren</returns>
        IQueryable<GehGassiFee> FilterGehGassiFees(string filter);

        /// <summary>
        /// Erstellen einer GehGassi-Gebühr
        /// </summary>
        /// <returns>GehGassi-Gebühr</returns>
        GehGassiFee CreateGehGassiFee();

        /// <summary>
        /// Gibt eine GehGassi-Gebühr zurück
        /// </summary>
        /// <param name="id">Id der Gebühr</param>
        /// <returns>Gebühr oder null, wenn nicht gefunden</returns>
        Task<GehGassiFee> GetGehGassiFeeAsync(string id);

        /// <summary>
        /// Prüft ob schon eine Einstellung für einen Startbetrag vorhanden ist
        /// </summary>
        /// <param name="startAmmount">Startbetrag</param>
        /// <param name="ignoreId">ID die ignoriert werden soll</param>
        /// <returns>true wenn bereits vorhanden, false sonst</returns>
        Task<bool> ExistsGehGassiFeeAsync(decimal startAmmount, string ignoreId);

        /// <summary>
        /// Hinzufügen einer GehGassi-Gebühr
        /// </summary>
        /// <param name="gehGassiFee">GehGassi-Gebühr</param>
        void AddGehGassiFee(GehGassiFee gehGassiFee);

        /// <summary>
        /// Löschen einer GehGassi-Gebühr
        /// </summary>
        /// <param name="gehGassiFee">GehGassi-Gebühr</param>
        void RemoveGehGassiFee(GehGassiFee gehGassiFee);

        /// <summary>
        /// Gibt eine GehGassi-Gebühr zurück die für den Startbetrag gilt
        /// </summary>
        /// <param name="startAmmount">Start-Betrag</param>
        /// <returns>Gebühr oder null, wenn nicht gefunden</returns>
        Task<GehGassiFee> GetMinGehGassiFeeAsync(decimal startAmmount);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Zahlungstransaktionen ermöglicht
    /// </summary>
    public interface IPaymentTransactionService : IService<PaymentTransaction>
    {
        /// <summary>
        /// Erstellen einer Zahlungs-Transaktion
        /// </summary>
        /// <returns>Zahlungs-Transaktion</returns>
        PaymentTransaction Create();

        /// <summary>
        /// Gibt eine Transaktion anhand der MangoPay TransaktionsId zurück.
        /// Diese muss den entsprechenden TransaktionsTyp und Status haben
        /// </summary>
        /// <param name="transactionId">Id der Transaktion bei MangoPay</param>
        /// <param name="type">Typ der Transaktion</param>
        /// <param name="status">Status der Transaktion</param>
        /// <returns>Transaktion oder null, wenn nicht gefunden</returns>
        Task<PaymentTransaction> GetAsync(string transactionId, PaymentTransactionType type, PaymentTransactionStatus status);

        /// <summary>
        /// Gibt eine Transaktion anhand der MangoPay TransaktionsId zurück. Hier wird die zuletzt erstellte Transaktion zurückgegeben.
        /// Diese muss den entsprechenden TransaktionsTyp und Status haben
        /// </summary>
        /// <param name="transactionId">Id der Transaktion bei MangoPay</param>
        /// <param name="type">Typ der Transaktion</param>
        /// <returns>Transaktion oder null, wenn nicht gefunden</returns>
        Task<PaymentTransaction> GetAsync(string transactionId, PaymentTransactionType type);

        /// <summary>
        /// Erstellen einer Zahlungs-Transaktion
        /// </summary>
        /// <param name="transactionId">Id der Transaktion bei MangoPay</param>
        /// <param name="type">Typ der Transaktion</param>
        /// <param name="status">Status der Transaktion</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="targetAppUserId">Id des AppUsers der die Zahlung erhält</param>
        /// <param name="targetWalletId">Id des Wallets, auf das die Transaktion angewendet wird</param>
        /// <param name="sourceAppUserId">Id des AppUsers der die Zahlung veranlasst</param>
        /// <param name="sourceWalletId">Id des Wallets, von dem die Transaktion ausgeht</param>
        /// <param name="ammount">Betrag in der kleinsten Einheit der Währung</param>
        /// <param name="fromCredit">Zusätzlich vom Guthabenkonto in der kleinsten Einheit der Währung</param>
        /// <param name="currency">Währung ISO 4217 Code</param>
        /// <param name="payInType">Art der Zahlung</param>
        /// <returns>Zahlungs-Transaktion</returns>
        PaymentTransaction Create(string transactionId, PaymentTransactionType type, PaymentTransactionStatus status, string walkId, string targetAppUserId, string targetWalletId, string sourceAppUserId, string sourceWalletId, long ammount, long fromCredit, string currency, PayInType? payInType);

        /// <summary>
        /// Erstellen einer Zahlungs-Transaktion mit Fehlern nach Mangopay
        /// </summary>
        /// <param name="transactionId">Id der Transaktion bei MangoPay</param>
        /// <param name="type">Typ der Transaktion</param>
        /// <param name="status">Status der Transaktion</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="targetAppUserId">Id des AppUsers der die Zahlung erhält</param>
        /// <param name="targetWalletId">Id des Wallets, auf das die Transaktion angewendet wird</param>
        /// <param name="sourceAppUserId">Id des AppUsers der die Zahlung veranlasst</param>
        /// <param name="sourceWalletId">Id des Wallets, von dem die Transaktion ausgeht</param>
        /// <param name="ammount">Betrag in der kleinsten Einheit der Währung</param>
        /// <param name="fromCredit">Zusätzlich vom Guthabenkonto in der kleinsten Einheit der Währung</param>
        /// <param name="currency">Währung ISO 4217 Code</param>
        /// <param name="errorMessage">Fehlermeldung Mangopay</param>
        /// <param name="errorType">Fehlertyp nach Mangopay</param>
        /// <param name="errorMessages">Fehlermledungen nach Mangopay - Zusatzinfo</param>
        /// <param name="payInType">Art der Zahlung</param>
        /// <returns>Zahlungs-Transaktion</returns>
        PaymentTransaction Create(string transactionId, PaymentTransactionType type, PaymentTransactionStatus status, string walkId, string targetAppUserId, string targetWalletId, string sourceAppUserId, string sourceWalletId, long ammount, long fromCredit, string currency, string errorMessage, string errorType, Dictionary<string,string> errorMessages, PayInType? payInType);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von KYC-Dokumenten ermöglicht
    /// </summary>
    public interface IIdentityDocumentService : IService<IdentityDocument>
    {
        /// <summary>
        /// Erstellen eines KYC-Dokuments
        /// </summary>
        /// <returns>IdentityDocument</returns>
        IdentityDocument Create();

        /// <summary>
        /// Erstellen eines KYC-Dokuments
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="mangoPayId">Id des KYC-Dokumentes bei MangoPay</param>
        /// <param name="mangoPayUserId">Id des Users bei MangoPay</param>
        /// <param name="documentType">Typ des Dokumentes</param>
        /// <param name="source">Quelle / Dokumentenart</param>
        /// <param name="status">Status der Validierung des Dokumentes</param>
        /// <param name="pageCount">Anzahl der Seiten</param>
        /// <returns>IdentityDocument</returns>
        IdentityDocument Create(string appUserId, string mangoPayId, string mangoPayUserId, IdentityDocumentType documentType, IdentityDocumentSource source, IdentityDocumentStatus status, int pageCount);

        /// <summary>
        /// Gibt ein KYC-Dokument anhand der MangoPayId zurück
        /// </summary>
        /// <param name="mangoPayId">Id des Dokumentes bei MangoPay</param>
        /// <returns>IdentityDocument oder null, wenn nicht gefunden</returns>
        Task<IdentityDocument> GetByMangoPayIdAsync(string mangoPayId);

        /// <summary>
        /// Gibt ein KYC-Dokument zurück, bei welchem die Validierung noch läuft
        /// </summary>
        /// <param name="appUserId">Id des App-USers</param>
        /// <returns>IdentityDocument oder null, wenn keines gefunden</returns>
        Task<IdentityDocument> GetValidationInProgressAsync(string appUserId);

        /// <summary>
        /// Gibt das zuletzt erstellte KYC-Dokument für einen App-User zurück
        /// </summary>
        /// <param name="appUserId">Id des App-USers</param>
        /// <returns>IdentityDocument oder null, wenn keines gefunden</returns>
        Task<IdentityDocument> GetLatestAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Auszahlungen ermöglicht
    /// </summary>
    public interface IPayoutService : IService<Payout>
    {
        /// <summary>
        /// Erstellen einer Auszahlung
        /// </summary>
        /// <returns>Payout</returns>
        Payout Create();

        /// <summary>
        /// Erstellen einer Auszahlung
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="mangoPayUserId">Id des Users bei MangoPay</param>
        /// <param name="mangoPayId">Id der Auszahlung bei MangoPay</param>
        /// <param name="walletId">Id des Wallets</param>
        /// <param name="mangoPayWalletId">Id des Wallets bei MangoPay</param>
        /// <param name="mangoPayBankId">Id der Bankverbindung bei mangoPay</param>
        /// <param name="iban">Iban letzte 4 Stellen</param>
        /// <param name="bic">Bic letzte 4 Stellen oder leer</param>
        /// <param name="ammount">Summe die ausgezahlt werden soll in der kleinsten Einheit</param>
        /// <param name="currency">Währung ISO 4217 Code</param>
        /// <returns>Payout</returns>
        Payout Create(string appUserId, string mangoPayUserId, string mangoPayId, string walletId, string mangoPayWalletId, string mangoPayBankId, string iban, string bic, long ammount, string currency);

        /// <summary>
        /// Gibt eine Liste der Auszahlungen eines Benutzers zurück.
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der öffentlichen Anfragen</returns>
        Task<List<Payout>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate);

        /// <summary>
        /// Gibt eine Auszahlung anhand der MangoPayId zurück
        /// </summary>
        /// <param name="mangoPayId">Id der Auszahlung bei MangoPay</param>
        /// <returns>Payout oder null, wenn nicht gefunden</returns>
        Task<Payout> GetByMangoPayIdAsync(string mangoPayId);

        /// <summary>
        /// Gibt eine Liste von Auszahlungen zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="sortList">Optional: Liste der sortierung</param>
        /// <param name="skip">Datensätze auslassen</param>
        /// <param name="take">Datensätze nehmen</param>
        /// <returns>Liste gefudene Walks</returns>
        Task<(int total, List<Payout> list)> GetAsync(string appUserId, List<DynamicSortOrder> sortList, int skip, int take);

        /// <summary>
        /// Gibt die letzte Auszahlung eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des Benutzers</param>
        /// <returns>Auszahlung oder null, wenn nicht gefunden</returns>
        Task<Payout> GetLastPayoutAsync(string appUserId);

        /// <summary>
        /// Gibt die Anzahl der Auszahlungen eines Benutzers in einem Zeitrahmen zurück
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <param name="startDate">Startdatum</param>
        /// <param name="endDate">Enddatum</param>
        /// <returns>Anzahl Auszahlungen</returns>
        Task<int> CountPayoutsInTimeRangeAsync(string appUserId, DateTimeOffset startDate, DateTimeOffset endDate);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Walk-Beschwerden ermöglicht
    /// </summary>
    public interface IWalkComplaintService : IService<WalkComplaint>
    {
		/// <summary>
		/// Erstellen einer Walk-Beschwerde
		/// </summary>
		/// <returns>Walk</returns>
		WalkComplaint Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Walk-Beschwerden mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Walk-Beschwerden</returns>
        IQueryable<WalkComplaintWithNames> FilterWithNames(string filter, bool includeDeleted);

        /// <summary>
        /// Gibt eine Walk-Beschwerden mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="id">Id der Beschwerde</param>
        /// <returns>Walk-Beschwerden mit Namen aufgelöst</returns>
        Task<WalkComplaintWithNames> GetWithNamesAsync(string id);

        /// <summary>
        /// Gibt eine Walk-Beschwerden mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="walkId">Id des Walks</param>
        /// <returns>Walk-Beschwerden mit Namen aufgelöst</returns>
        Task<WalkComplaintWithNames> GetWithNamesByWalkAsync(string walkId);

        /// <summary>
        /// Gibt eine Walk-Beschwerden zurück
        /// </summary>
        /// <param name="walkId">Id des Walks</param>
        /// <returns>Walk-Beschwerden</returns>
        Task<WalkComplaint> GetByWalkAsync(string walkId);

        /// <summary>
        /// Gibt die Anzahl der Walk-Beschwerden mit einem bestimmten Status zurück
        /// </summary>
        /// <param name="status">Gewünschter Status</param>
        /// <returns>Anzahl Beschwerden im Status</returns>
        Task<int> CountAsync(WalkComplaintStatus status);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der Statistiken zur Verfügung stellt
    /// </summary>
    public interface IStatisticService
    {
        /// <summary>
        /// Gibt zurück wie viele gültige Walks insgesamt vorhanden sind.
        /// Das sind alle Walks die nicht folgenden Status haben:
        /// - Requested
        /// - Declined
        /// - Cancelled
        /// </summary>
        /// <param name="minPaymentStatus">Minimaler Zahlungsstatus, null wenn alle</param>
        /// <param name="maxPaymentStatus">Maximaler Zahlungsstatus, null wenn alle</param>
        /// <param name="countryIso">Land oder leer wenn alle</param>
        /// <returns>Anzahl Walks</returns>
        Task<int> CountWalksTotalAsync(PaymentStatus? minPaymentStatus, PaymentStatus? maxPaymentStatus, string countryIso);

        /// <summary>
        /// Gibt zurück wie viele gültige Walks in einem Zeitraum vorhanden sind.
        /// Das sind alle Walks die nicht folgenden Status haben:
        /// - Requested
        /// - Declined
        /// - Cancelled
        /// </summary>
        /// <param name="minPaymentStatus">Minimaler Zahlungsstatus, null wenn alle</param>
        /// <param name="maxPaymentStatus">Maximaler Zahlungsstatus, null wenn alle</param>
        /// <param name="start">Startdatum</param>
        /// <param name="end">Enddatum</param>
        /// <param name="countryIso">Land oder leer wenn alle</param>
        /// <returns>Anzahl Walks</returns>
        Task<int> CountWalksAsync(PaymentStatus? minPaymentStatus, PaymentStatus? maxPaymentStatus, DateTimeOffset start, DateTimeOffset end, string countryIso);

        /// <summary>
        /// Gibt die Anzahl von Walks in einem bestimmten Status in einem Zeitraum zurück
        /// </summary>
        /// <param name="status">Status der gesucht wird, null wenn alle</param>
        /// <param name="minPaymentStatus">Minimaler Zahlungsstatus, null wenn alle</param>
        /// <param name="maxPaymentStatus">Maximaler Zahlungsstatus, null wenn alle</param>
        /// <param name="start">Startdatum</param>
        /// <param name="end">Enddatum</param>
        /// <param name="countryIso">Land oder leer wenn alle</param>
        /// <returns>Anzahl Walks</returns>
        Task<int> CountWalkByStatusAsync(WalkStatus? status, PaymentStatus? minPaymentStatus, PaymentStatus? maxPaymentStatus, DateTimeOffset start, DateTimeOffset end, string countryIso);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von App-User-Reports ermöglicht
    /// </summary>
    public interface IAppUserReportService : IService<AppUserReport>
	{
		/// <summary>
		/// Erstellen einer Meldung
		/// </summary>
		/// <returns>AppFeedback</returns>
		AppUserReport Create();

		/// <summary>
		/// Gibt eine gefilterte Liste von Meldungen zurück
		/// </summary>
		/// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
		/// <returns>List betroffener Feedbacks</returns>
		IQueryable<AppUserReport> Filter(string filter);

		/// <summary>
		/// Gibt eine gefilterte Liste von Meldungen zurück
		/// </summary>
		/// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
		/// <returns>List betroffener Feedbacks</returns>
		IQueryable<AppUserReportWithNames> FilterWithNames(string filter);

        /// <summary>
        /// Gibt die Anzahl von Meldungen in einem bestimmten Status zurück
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <returns>Anzahl Meldungen im Status</returns>
        Task<int> CountAsync(AppUserReportStatus status);

        /// <summary>
        /// Gibt eine Meldung mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="id">Id der Meldung</param>
        /// <returns>AppUserReportWithNames oder null, wenn nicht gefunden</returns>
        Task<AppUserReportWithNames> GetWithNamesAsync(long id);

        /// <summary>
        /// Gibt zurück wie viele Meldungen ein App-User erstellt hat
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>Anzahl Meldungen</returns>
        Task<int> CountReportingAsync(string appUserId);

        /// <summary>
        /// Gibt zurück wie viele Meldungen für ein App-User erstellt wurden
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>Anzahl Meldungen erstellt</returns>
        Task<int> CountReportedAsync(string appUserId);

        /// <summary>
        /// Löscht alle Meldungen and denen ein AppUser beteiligt ist
        /// </summary>
        /// <param name="appUserId">Id des App-Users</param>
        /// <returns>Anzahl Meldungen gelöscht</returns>
        Task<int> DeleteAllForAppUserAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von FAQs realisiert
    /// </summary>
    public interface IFaqService : IService<Faq>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von FAQs zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener FAQs</returns>
        IQueryable<Faq> Filter(string filter);

        /// <summary>
        /// Erstellen einer FAQ
        /// </summary>
        /// <returns>Faq</returns>
        Faq Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von FAQs zurück. Sucht nur im Titel
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener FAQs</returns>
        Task<List<Faq>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von FAQs mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener FAQs</returns>
        IQueryable<FaqWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von FAQs zurück, welche nach dem glieferten Datum geändert wurden.
        /// Wird kein Datum angegeben, werden alle zurückgegeben.
        /// Es werden alle Kategorien zurückgegeben - egal ob on- oder offline.
        /// </summary>
        /// <param name="lastUpdate">Letztes Update oder null wenn noch keines</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste von FAQs</returns>
        Task<List<FaqWithNames>> GetForSyncAsync(DateTimeOffset? lastUpdate, string language, string fallback);

        /// <summary>
        /// Erstellt das FAQ-Html für die Integration in die FAQ-Seite.
        /// Es werden alle FAQs genommen, welche Online sind und nicht gelöscht wurden
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="type">Typ</param>
        /// <returns>string - HTML</returns>
        Task<string> GenerateHtmlForPageAsync(string language, string fallback, FaqType type);

        /// <summary>
        /// Gibt eine Liste aller FAQ mit einem speziellen Typ zurück
        /// </summary>
        /// <param name="type">Typ</param>
        /// <returns>Liste FAQ</returns>
        Task<List<Faq>> GetAllAsync(FaqType type);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Coin-Konten, Transaktionen und Monats- und Jahresstatistiken realisiert
    /// </summary>
    public interface ICoinsService : IService<CoinsAccount>
    {
        /// <summary>
        /// Gibt einen Coin-Account zurück oder erstellt einen neuen wenn noch nicht vorhanden
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <returns>CoinAccount</returns>
        Task<CoinsAccount> GetOrCreateAsync(string appUserId, AppUserType appUserType);

        /// <summary>
        /// Einzahlen einer Coins-Summe auf das passende Konto eines AppUsers
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <param name="ammount">Coins-Betrag der eingezahlt werden soll</param>
        /// <param name="walkId">Optional: Id des Walks auf den sich die Transaktion bezieht</param>
        /// <returns>Transaktion</returns>
        Task<CoinsTransaction> DepositAsync(string appUserId, AppUserType appUserType, decimal ammount, string walkId);

        /// <summary>
        /// Abbuchen einer Coins-Summe von dem passenden Konto eines AppUsers
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <param name="ammount">Coins-Betrag der eingezahlt werden soll</param>
        /// <returns>CoinsTransaction</returns>
        Task<CoinsTransaction> WithdrawAsync(string appUserId, AppUserType appUserType, decimal ammount);

        /// <summary>
        /// Gibt den Coins-Stand eines AppUsers für einen Monat zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <param name="date">Datum</param>
        /// <returns>CoinsPerMonth</returns>
        Task<CoinsPerMonth> GetOrCreateCoinsPerMonthAsync(string appUserId, AppUserType appUserType, DateTimeOffset date);

        /// <summary>
        /// Gibt den Coins-Stand eines AppUsers für ein Jahr zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <param name="date">Datum</param>
        /// <returns>CoinsPerYear</returns>
        Task<CoinsPerYear> GetOrCreateCoinsPerYearAsync(string appUserId, AppUserType appUserType, DateTimeOffset date);

        /// <summary>
        /// Gibt die Top X der Coins je Monat für ein Jahr und Monat zurück.
        /// Sortiert nach Coins absteigend und bei Gleichstand nach LastUpdate aufsteigend
        /// </summary>
        /// <param name="count">Anzalh Datensätze</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <param name="year">Jahr</param>
        /// <param name="month">Monat</param>
        /// <param name="minBalance">Mindest-Wert der erreicht werden musste</param>
        /// <returns>Liste CoinsPerMonthWithNames</returns>
        Task<List<CoinsPerMonthWithNames>> GetMonthlyTopAsync(int count, AppUserType appUserType, int year, int month, decimal minBalance);

        /// <summary>
        /// Gibt die Top X der Coins je Jahr zurück.
        /// Sortiert nach Coins absteigend und bei Gleichstand nach LastUpdate aufsteigend
        /// </summary>
        /// <param name="count">Anzalh Datensätze</param>
        /// <param name="appUserType">Typ des AppUsers</param>
        /// <param name="year">Jahr</param>
        /// <param name="minBalance">Mindest-Wert der erreicht werden musste</param>
        /// <returns>Liste CoinsPerMonthWithNames</returns>
        Task<List<CoinsPerYearWithNames>> GetYearlyTopAsync(int count, AppUserType appUserType, int year, decimal minBalance);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Appversionen realisiert
    /// </summary>
    public interface IAppVersionService : IService<AppVersion>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Appversionen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener AppVersionen</returns>
        IQueryable<AppVersion> Filter(string filter);

        /// <summary>
        /// Erstellen einer Appversion
        /// </summary>
        /// <returns>Listung</returns>
        AppVersion Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Appversionen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Appversionen</returns>
        Task<List<AppVersion>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Appversionen mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste betroffener Appversionen</returns>
        IQueryable<AppVersionWithNames> FilterWithNames(string filter, string language, string fallback);

        /// <summary>
        /// Gibt zurück ob eine Versionsnummer für eine Plattform bereits existiert
        /// </summary>
        /// <param name="platform">Plattform</param>
        /// <param name="version">Versionsnummer die geprüft werden soll</param>
        /// <param name="ignoreId">ID die ignoriert werden soll</param>
        /// <returns>true wenn eine existiert, false sonst</returns>
        Task<bool> VersionExistsAsync(Platform platform, string version, int ignoreId);

        /// <summary>
        /// Gibt zurück ob eine Plattform eine aktuelle Version hat
        /// </summary>
        /// <param name="platform">Plattform</param>
        /// <param name="ignoreId">ID die ignoriert werden soll</param>
        /// <returns>true wenn eine existiert, false sonst</returns>
        Task<bool> HasCurrentAsync(Platform platform, int ignoreId);

        /// <summary>
        /// Zurücksetzen der aktuellen Version einer Plattform. Es kann nur einen geben :)
        /// </summary>
        /// <param name="platform">Plattform</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>Task</returns>
        Task ResetCurrentAsync(Platform platform, string userName);

        /// <summary>
        /// Gibt die aktuelle Version einer Plattform zurück
        /// </summary>
        /// <param name="platform">Plattform</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Aktuelle Version oder null, wenn keine vorhanden</returns>
        Task<AppVersionWithNames> GetCurrentwithNamesAsync(Platform platform, string language, string fallback);

    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Gutschein Kampagnen realisiert
    /// </summary>
    public interface IVoucherCampaignService : IService<VoucherCampaign>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Gutschein-Kampagnen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Gutschein-Kampagnen</returns>
        IQueryable<VoucherCampaign> Filter(string filter);

        /// <summary>
        /// Erstellen einer Gutschein-Kampagne
        /// </summary>
        /// <returns>Gutschein-Kampagne</returns>
        VoucherCampaign Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Gutschein-Kampagnen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Gutschein-Kampagnen</returns>
        Task<List<VoucherCampaign>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Gutschein-Kampagnen mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Gutschein-Kampagnen</returns>
        IQueryable<VoucherCampaignWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt eine gefilterte Liste von Gutschein-Kampagnen mit Namen für Kunden zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="customerId">Id des Kunden</param>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Liste betroffener Gutschein-Kampagnen</returns>
        IQueryable<VoucherCampaignWithNames> FilterWithNamesCustomer(long customerId, string filter, string language, string fallback, bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt die Anzahl von Gutschein-Kampagnen zurück
        /// </summary>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <param name="excludeDraft">Sollen Entitäten im Draft-Status (Cart) ausgeblendet werden?</param>
        /// <returns>Anzahl Gutschein-Kampagnen</returns>
        Task<int> CountAsync(bool includeDeleted, bool excludeDraft);

        /// <summary>
        /// Gibt die Anzahl von Gutschein-Kampagnen in einem Status zurück
        /// </summary>
        /// <param name="status">Gesuchter Status</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Anzahl Gutschein-Kampagnen</returns>
        Task<int> CountAsync(VoucherCampaignStatus status, bool includeDeleted);

        /// <summary>
        /// Gibt eine Gutschein-Kampagne für einen Artikel im Warenkorb zurück
        /// </summary>
        /// <param name="cartItemId">Id des Artikels im Warenkorb</param>
        /// <returns>Gutschein-Kampagne oder null, wenn nicht gefunden</returns>
        Task<VoucherCampaign> GetByCartItemAsync(long cartItemId);

        /// <summary>
        /// Gibt einen Gutschein-Kampagne für einen Artikel in einer Bestellung zurück
        /// </summary>
        /// <param name="orderItemId">Id des Artikels in der Bestellung</param>
        /// <returns>Gutschein-Kampagne oder null, wenn nicht gefunden</returns>
        Task<VoucherCampaign> GetByOrderItemAsync(long orderItemId);

        /// <summary>
        /// Setzen des Status von Gutschein-Kampagnen nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Gutschein-Kampagnen</returns>
        Task<int> SetStatusByOrderAsync(long orderId, VoucherCampaignStatus status);

        /// <summary>
        /// Setzen des Bezahlstatus von Gutschein-Kampagnen nach Bestellung
        /// </summary>
        /// <param name="orderId">Id der Bestellung</param>
        /// <param name="status">Zu setzender Status</param>
        /// <returns>Anzahl betroffener Gutschein-Kampagnen</returns>
        Task<int> SetPaymentStatusByOrderAsync(long orderId, PaymentStatus status);

        /// <summary>
        /// Starten von gebuchten Gutschein-Kampagnen wenn diese das Start-Datum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestartete Gutschein-Kampagnen</returns>
        Task<int> StartBookedAsnyc();

        /// <summary>
        /// Stoppen von abgelaufenen Gutschein-Kampagnen wenn diese das Enddatum erreicht haben
        /// </summary>
        /// <returns>Anzahl gestoppte Gutschein-Kampagnen</returns>
        Task<int> StopRunningAsync();

        /// <summary>
        /// Erstellen von Gutscheinen für eine Gutschein-Kampagne
        /// </summary>
        /// <param name="voucherCampaignId">Id der Kampagne</param>
        /// <param name="userName">Der Benutzer der die Gutscheine angelegt hat</param>
        /// <returns>Anzahl der erstellten Gutscheine</returns>
        Task<int> CreateVouchersForCampaign(string voucherCampaignId, string userName);

        /// <summary>
        /// Prüft ob ein Präfix für eine Gutschein-Kampagne verfügbar ist
        /// </summary>
        /// <param name="prefix">Präfix der geprüft werden soll</param>
        /// <param name="voucherCampaignId">Id der Kampagne die ignoriert werden soll</param>
        /// <returns>true wenn verfügbar, false sonst</returns>
        Task<bool> IsPrefixAvailableAsync(string prefix, string voucherCampaignId);

        /// <summary>
        /// Aktualisiert den Gutschein-Betrag für alle noch nicht eingelösten oder deaktivierten Gutscheine einer Kampagne
        /// </summary>
        /// <param name="voucherCampaignId">Id der Kampagne</param>
        /// <param name="voucherAmmount">Wert der gesetzt werden soll</param>
        /// <returns>Anzahl Gutscheine die betroffen sind</returns>
        Task<int> UpdateVoucherAmmountAsync(string voucherCampaignId, decimal voucherAmmount);

        /// <summary>
        /// Löschen der Gutscheine und deren Verwendung für eine Kampagne
        /// </summary>
        /// <param name="voucherCampaignId">Id der Kampagne</param>
        /// <returns>Anzahl gelöscht</returns>
        Task<int> RemoveVouchersAsync(string voucherCampaignId);

        /// <summary>
        /// Gibt eine Liste von Gutscheinen für eine Kampagne zurück
        /// </summary>
        /// <param name="voucherCampaignId">Id der Kampagne</param>
        /// <returns>Liste Gutscheine</returns>
        Task<List<Voucher>> GetVouchersForCampaignAsync(string voucherCampaignId);

        /// <summary>
        /// Prüft ob ein manueller Gutscheincode für einen Benutzer gültig ist und eingesetzt werden kann
        /// </summary>
        /// <param name="code">Code</param>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Validierungs-Ergebnis</returns>
        Task<VoucherValidationResult> ValidateVoucherCodeAsync(string code, string appUserId);

        /// <summary>
        /// Gibt einen Gutschein anhand des Codes zurück
        /// </summary>
        /// <param name="code">Code des Gutscheins</param>
        /// <returns>Gutschein oder null, wenn nicht gefunden</returns>
        Task<Voucher> GetVoucherByCodeAsync(string code);

        /// <summary>
        /// Gibt einen Gutschein anhand des QR-Codes zurück
        /// </summary>
        /// <param name="qrCode">QR-Code des Gutscheins</param>
        /// <returns>Gutschein oder null, wenn nicht gefunden</returns>
        Task<Voucher> GetVoucherByQrCodeAsync(string qrCode);

        /// <summary>
        /// Reserviert einen Gutschein für einen Benutzer und einen Walk
        /// </summary>
        /// <param name="voucherId">Id des Vouchers</param>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="walkId">Id des Walks</param>
        /// <param name="voucherAmmount">Wert des Gutscheins</param>
        /// <param name="voucherAmmountUsed">Wert der verbraucht wurde. Kann kleiner Gutscheinwert sein</param>
        /// <returns>VoucherUsage</returns>
        Task<VoucherUsage> ReserveVoucherAsync(string voucherId, string? appUserId, string? walkId, decimal voucherAmmount, decimal voucherAmmountUsed);

        /// <summary>
        /// Löschen der Verwendung eines Gutscheins
        /// </summary>
        /// <param name="voucherUsage">VoucherUsage</param>
        void RemoveUsage(VoucherUsage voucherUsage);

        /// <summary>
        /// Gibt die Verwendung eines Gutscheins zurück
        /// </summary>
        /// <param name="voucherId">Id des Gutscheins</param>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="walkId">Id des Walks</param>
        /// <returns>VoucherUsage oder null, wenn nicht gefunden</returns>
        Task<VoucherUsage> GetUsageAsync(string voucherId, string? appUserId, string? walkId);

        /// <summary>
        /// Gibt einen Gutschein zurück
        /// </summary>
        /// <param name="voucherId">Id des Gutscheins</param>
        /// <returns>Voucher oder null, wenn nicht gefunden</returns>
        Task<Voucher> GetVoucherAsync(string voucherId);

        /// <summary>
        /// Löschen von Voucher-Usages für einen AppUser
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Anzahl gelöscht</returns>
        Task<int> RemoveVoucherUsageForAppUserAsync(string appUserId);
    }

    /// <summary>
    /// Schnittstellenbeschreibung für einen Service der die Verwaltung von Abonnements realisiert
    /// </summary>
    public interface ISubscriptionService : IService<Subscription>
    {
        /// <summary>
        /// Gibt eine gefilterte Liste von Abonnements zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Abonnements</returns>
        IQueryable<Subscription> Filter(string filter);

        /// <summary>
        /// Erstellen eines Abonnements
        /// </summary>
        /// <returns>Abonnement</returns>
        Subscription Create();

        /// <summary>
        /// Gibt eine gefilterte Liste von Abonnements zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Abonnements</returns>
        Task<List<Subscription>> SearchAsync(string filter);

        /// <summary>
        /// Gibt eine gefilterte Liste von Abonnements mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Abonnements</returns>
        IQueryable<SubscriptionWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted);

        /// <summary>
        /// Gibt eine Liste von Abonnements zurück, welche dem gesuchten AppMode entsprechend und aktiv sind
        /// </summary>
        /// <param name="appMode">Gesuchter App mode</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste Abonnements</returns>
        Task<List<SubscriptionWithNames>> GetAllAsync(AppMode appMode, string language, string fallback);

        /// <summary>
        /// Gibt eine gefilterte Liste von Abonnements mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste betroffener Abonnements</returns>
        IQueryable<AppUserSubscriptionWithNames> FilterAppUserSubscritionsWithNames(string filter, string language, string fallback);

        /// <summary>
        /// Gibt eine Liste von Abonnements zurück, welche ein App-User abonniert hat
        /// </summary>
        /// <param name="appUserId">App user id</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste betroffener Abonnement-Buchungen</returns>
        Task<List<AppUserSubscriptionWithNames>> GetAllAppUserSubscriptionsAsync(string appUserId, string language, string fallback);

        /// <summary>
        /// Gibt eine Liste von Abonnements zurück, welche ein App-User abonniert hat die gültig und aktiv sind
        /// </summary>
        /// <param name="appUserId">App user id</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste betroffener Abonnement-Buchungen</returns>
        Task<List<AppUserSubscriptionWithNames>> GetAllAppUserSubscriptionsValidAsync(string appUserId, string language, string fallback);

        /// <summary>
        /// Gibt eine Abonnementbuchung mit Namen zurück
        /// </summary>
        /// <param name="id">Id der Buchung</param>
        /// <param name="language"></param>
        /// <param name="fallback"></param>
        /// <returns>AppUserSubscriptionWithNames</returns>
        Task<AppUserSubscriptionWithNames> GetAppUserSubscriptionAsync(long id, string language, string fallback);

        /// <summary>
        /// Erstellen eines Abonnements für einen App-User
        /// </summary>
        /// <returns>Abonnement</returns>
        AppUserSubscription CreateAppUserSubscription();

        /// <summary>
        /// Gibt ein App-User-Abonnement zurück
        /// </summary>
        /// <param name="id">AppUserSubcription  id</param>
        /// <returns>AppUserSubscription</returns>
        Task<AppUserSubscription> GetAppUserSubscriptionAsync(long id);

        /// <summary>
        /// Gibt ein App-User-Abonnement zurück
        /// </summary>
        /// <param name="appUserId">App user id</param>
        /// <param name="subscriptionId">Abo-Id</param>
        /// <returns>AppUserSubscription oder null, wenn nicht gefunden</returns>
        Task<AppUserSubscription> GetAppUserSubscriptionAsync(string appUserId, string subscriptionId);

        /// <summary>
        /// Fügt eine Entität zum Repository hinzu
        /// </summary>
        /// <param name="entity">Entität</param>
        void AddAppUserSubscription(AppUserSubscription entity);

        /// <summary>
        /// Entfernt eine Entität aus dem Repository
        /// </summary>
        /// <param name="entity">Zu entfernende Entität</param>
        void RemoveAppUserSubscription(AppUserSubscription entity);

        /// <summary>
        /// Prüft ob ein App-User ein Abonnement hat für einen AppMode das noch gültig ist
        /// </summary>
        /// <param name="appUserId">App user id</param>
        /// <param name="appMode">AppMode</param>
        /// <returns>true wenn ja, false else</returns>
        Task<bool> AppUserHasActiveBookingAsync(string appUserId, AppMode appMode);

        /// <summary>
        /// Setzt Abo-Buchungen die abgelaufen sind auf ungültig
        /// </summary>
        /// <returns></returns>
        Task<int> InvalidateExipredAppUserSubscriptionsAsync(DateTimeOffset date);
    }


    #region Helper

        /// <summary>
        /// Repräsentiert ein Validierungsergebnis für die Prüfung ob eine Listung möglich ist
        /// </summary>
        public class ListingValidationResult
    {
        /// <summary>
        /// Validierung erfolgreich oder nicht?
        /// </summary>
        public bool Valid { get; set; }
        
        /// <summary>
        /// Wie viele Listungen für die Branche, den Listungstyp und den gewählten Zeitraum liegen vor
        /// </summary>
        public int Booked { get; set; }

        /// <summary>
        /// Wie viele Reservierungen liegen vor?
        /// </summary>
        public int Reserved { get; set; }

        /// <summary>
        /// Fehlercode, wenn nicht valide
        /// </summary>
        public ListingValidationError ErrorCode { get; set; }
    }

    /// <summary>
    /// Validierungsfehler für die Prüfung ob eine Listung durchgeführt werden kann
    /// </summary>
    public enum ListingValidationError
    {
        /// <summary>
        /// Kein FEhler
        /// </summary>
        None = 0,
        /// <summary>
        /// Listung nicht möglich da Kapazitäten verbraucht
        /// </summary>
        NoSlotsAvailable = 1,
        /// <summary>
        /// Vom Kunden bereits gebucht
        /// </summary>
        AlreadyBooked = 10
    }

    /// <summary>
    /// Ergebnis einer Steuerberechnung
    /// </summary>
    public class TaxGrossResult
    {
        /// <summary>
        /// Berechneter Wert
        /// </summary>
        public decimal Value { get; set; }

        /// <summary>
        /// Steuerstufe - z.B. 10% oder 20%
        /// </summary>
        public decimal TaxRate { get; set; }

        /// <summary>
        /// Wert für die Steuerstufe
        /// </summary>
        public decimal TaxValue { get; set; }
    }

    #endregion
}