516 lines
27 KiB
C#
516 lines
27 KiB
C#
using gehGassi.Core.Interfaces;
|
|
using gehGassi.Domain.Advertisements;
|
|
using gehGassi.Domain.Common;
|
|
using gehGassi.Domain.Walks;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using NetTopologySuite.Geometries;
|
|
using NetTopologySuite;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using gehGassi.Common.Extensions;
|
|
|
|
namespace gehGassi.Core.Services
|
|
{
|
|
/// <summary>
|
|
/// Service der die Verwaltung von öffentlichen Anfragen ermöglicht
|
|
/// </summary>
|
|
public class PublicWalkRequestService : ServiceBase<PublicWalkRequest>, IPublicWalkRequestService
|
|
{
|
|
private readonly IRepository<PublicWalkRequestWithNames> _namesRepository;
|
|
private readonly IRepository<PublicWalkRequestWithNamesAndResponseStatus> _namesWithStatusRepository;
|
|
private readonly IRepository<PublicWalkResponse> _responsesRepository;
|
|
private readonly IRepository<PublicWalkRequestNotification> _notificationsRepository;
|
|
|
|
/// <summary>
|
|
/// Erstellt eine Instanz
|
|
/// </summary>
|
|
/// <param name="unitOfWork">Instanz eines IUnitOfWork</param>
|
|
public PublicWalkRequestService(IUnitOfWork unitOfWork) : base(unitOfWork)
|
|
{
|
|
_namesRepository = unitOfWork.GetRepository<PublicWalkRequestWithNames>();
|
|
_namesWithStatusRepository = unitOfWork.GetRepository<PublicWalkRequestWithNamesAndResponseStatus>();
|
|
_responsesRepository = unitOfWork.GetRepository<PublicWalkResponse>();
|
|
_notificationsRepository = unitOfWork.GetRepository<PublicWalkRequestNotification>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erstellen einer öffentlichen Anfrage
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public PublicWalkRequest Create()
|
|
{
|
|
var request = new PublicWalkRequest
|
|
{
|
|
Id = Guid.NewGuid().ToString("N"),
|
|
Created = DateTimeOffset.UtcNow
|
|
};
|
|
|
|
return request;
|
|
}
|
|
|
|
/// <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>
|
|
public async Task<List<PublicWalkRequest>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate)
|
|
{
|
|
var query = Repository.Query(c => c.DogOwnerId == appUserId);
|
|
|
|
if (lastUpdate.HasValue)
|
|
query = query.Where(c => c.UpdatedAt > lastUpdate);
|
|
|
|
return await query.ToListAsync().ConfigureAwait(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt die anzahl öffentlicher Anfragen eines AppUsers zurück
|
|
/// </summary>
|
|
/// <param name="appUserId">AppUserId</param>
|
|
/// <returns>Anzahl öffentliche Anfragen</returns>
|
|
public async Task<int> CountAsync(string appUserId)
|
|
{
|
|
var items = await Repository.CountAsync(c => c.DogOwnerId == appUserId);
|
|
return items;
|
|
}
|
|
|
|
/// <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>
|
|
public async Task<List<PublicWalkRequestWithNames>> GetLatestAsync(string appUserId, int take)
|
|
{
|
|
var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_PublicWalkRequestWithNames()", c => c.DogOwnerId == appUserId && c.Deleted == false);
|
|
|
|
var requests = await baseQuery.OrderByDescending(c => c.UpdatedAt).Take(take).ToListAsync();
|
|
return requests;
|
|
}
|
|
|
|
|
|
/// <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>
|
|
public async 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)
|
|
{
|
|
var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_PublicWalkRequestWithNames()", c => c.Deleted == false);
|
|
if (status.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.Status == status);
|
|
if (!string.IsNullOrEmpty(ignoreId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId != ignoreId);
|
|
if (!string.IsNullOrEmpty(dogOwnerId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId == dogOwnerId);
|
|
if (!string.IsNullOrEmpty(dogWalkerId))
|
|
baseQuery = baseQuery.Where(c => c.DogWalkerId == dogWalkerId);
|
|
|
|
var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
|
|
var location = geometryFactory.CreatePoint(new Coordinate(lng, lat));
|
|
|
|
var total = await baseQuery.CountAsync().ConfigureAwait(false);
|
|
|
|
if (sortList.Any())
|
|
{
|
|
var isFirst = true;
|
|
var orderedBaseQuery = baseQuery.SpecialOrderBy(sortList.First().Property, sortList.First().SortDirection); ;
|
|
foreach (var sortOrder in sortList)
|
|
{
|
|
if (isFirst)
|
|
{
|
|
isFirst = false;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
orderedBaseQuery = orderedBaseQuery.SpecialThenBy(sortOrder.Property, sortOrder.SortDirection);
|
|
}
|
|
}
|
|
var list = await orderedBaseQuery.ThenBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
else
|
|
{
|
|
var list = await baseQuery.OrderBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
}
|
|
|
|
|
|
/// <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>
|
|
public async 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)
|
|
{
|
|
var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
|
|
var location = geometryFactory.CreatePoint(new Coordinate(lng, lat));
|
|
|
|
var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_PublicWalkRequestWithNames()", c => c.Deleted == false);
|
|
if (status.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.Status == status);
|
|
if (!string.IsNullOrEmpty(ignoreId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId != ignoreId);
|
|
if (!string.IsNullOrEmpty(dogOwnerId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId == dogOwnerId);
|
|
if (!string.IsNullOrEmpty(dogWalkerId))
|
|
baseQuery = baseQuery.Where(c => c.DogWalkerId == dogWalkerId);
|
|
if(type.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.RequestType == type);
|
|
if(minPrice > 0)
|
|
baseQuery = baseQuery.Where(c => c.Price >= minPrice);
|
|
|
|
baseQuery = baseQuery.Where(c => c.Location.IsWithinDistance(location, maxRadius * 1000));
|
|
|
|
var total = await baseQuery.CountAsync().ConfigureAwait(false);
|
|
|
|
if (sortList.Any())
|
|
{
|
|
var isFirst = true;
|
|
var orderedBaseQuery = baseQuery.SpecialOrderBy(sortList.First().Property, sortList.First().SortDirection); ;
|
|
foreach (var sortOrder in sortList)
|
|
{
|
|
if (isFirst)
|
|
{
|
|
isFirst = false;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
orderedBaseQuery = orderedBaseQuery.SpecialThenBy(sortOrder.Property, sortOrder.SortDirection);
|
|
}
|
|
}
|
|
var list = await orderedBaseQuery.ThenBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
else
|
|
{
|
|
var list = await baseQuery.OrderBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
}
|
|
|
|
/// <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="includeBlockedAndLocked">Sollten blockierte unnd/oder gesperrte Benutzer in die Liste eingefügt werden?</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="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>
|
|
public async 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)
|
|
{
|
|
var baseQuery = _namesWithStatusRepository.QueryStoredProcedure("SELECT * FROM tv_PublicWalkRequestWithNamesAndResponseStatus({0})", c => c.Deleted == false, targetDogWalkerId);
|
|
if (!includeBlockedAndLocked)
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerBlocked == false && c.DogOwnerLocked == false);
|
|
if (status.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.Status == status);
|
|
if (!string.IsNullOrEmpty(ignoreId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId != ignoreId);
|
|
if (!string.IsNullOrEmpty(dogOwnerId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId == dogOwnerId);
|
|
if (!string.IsNullOrEmpty(dogWalkerId))
|
|
baseQuery = baseQuery.Where(c => c.DogWalkerId == dogWalkerId);
|
|
if (responseStatus.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.ResponseStatus == responseStatus || c.ResponseStatus == null);
|
|
if (mustHaveResponse)
|
|
baseQuery = baseQuery.Where(c => c.ResponseStatus != null);
|
|
|
|
var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
|
|
var location = geometryFactory.CreatePoint(new Coordinate(lng, lat));
|
|
|
|
var total = await baseQuery.CountAsync().ConfigureAwait(false);
|
|
|
|
if (sortList.Any())
|
|
{
|
|
var isFirst = true;
|
|
var orderedBaseQuery = baseQuery.SpecialOrderBy(sortList.First().Property, sortList.First().SortDirection); ;
|
|
foreach (var sortOrder in sortList)
|
|
{
|
|
if (isFirst)
|
|
{
|
|
isFirst = false;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
orderedBaseQuery = orderedBaseQuery.SpecialThenBy(sortOrder.Property, sortOrder.SortDirection);
|
|
}
|
|
}
|
|
var list = await orderedBaseQuery.ThenBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
else
|
|
{
|
|
var list = await baseQuery.OrderBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
}
|
|
|
|
/// <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="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">Sollen 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="type">Typ der öffentlichen Anfrage, oder alle wenn NULL</param>
|
|
/// <param name="minPrice">Mindest-Preis</param>
|
|
/// <returns>Liste passender Anfragen</returns>
|
|
public async 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)
|
|
{
|
|
var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
|
|
var location = geometryFactory.CreatePoint(new Coordinate(lng, lat));
|
|
|
|
var baseQuery = _namesWithStatusRepository.QueryStoredProcedure("SELECT * FROM tv_PublicWalkRequestWithNamesAndResponseStatus({0})", c => c.Deleted == false, targetDogWalkerId);
|
|
if (!includeBlockedAndLocked)
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerBlocked == false && c.DogOwnerLocked == false);
|
|
if (status.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.Status == status);
|
|
if (!string.IsNullOrEmpty(ignoreId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId != ignoreId);
|
|
if (!string.IsNullOrEmpty(dogOwnerId))
|
|
baseQuery = baseQuery.Where(c => c.DogOwnerId == dogOwnerId);
|
|
if (!string.IsNullOrEmpty(dogWalkerId))
|
|
baseQuery = baseQuery.Where(c => c.DogWalkerId == dogWalkerId);
|
|
if (type.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.RequestType == type);
|
|
if (minPrice > 0)
|
|
baseQuery = baseQuery.Where(c => c.Price >= minPrice);
|
|
if (responseStatus.HasValue)
|
|
baseQuery = baseQuery.Where(c => c.ResponseStatus == responseStatus || c.ResponseStatus == null);
|
|
if (mustHaveResponse)
|
|
baseQuery = baseQuery.Where(c => c.ResponseStatus != null);
|
|
if (!string.IsNullOrWhiteSpace(searchText))
|
|
baseQuery = baseQuery.Where(c => c.DogName.Contains(searchText) || c.DogsJson.Contains(searchText) || c.DogOwnerName.Contains(searchText) || c.PickupAddress_City.Contains(searchText));
|
|
|
|
baseQuery = baseQuery.Where(c => c.Location.IsWithinDistance(location, maxRadius * 1000));
|
|
|
|
var total = await baseQuery.CountAsync().ConfigureAwait(false);
|
|
|
|
if (sortList.Any())
|
|
{
|
|
var isFirst = true;
|
|
var orderedBaseQuery = baseQuery.SpecialOrderBy(sortList.First().Property, sortList.First().SortDirection); ;
|
|
foreach (var sortOrder in sortList)
|
|
{
|
|
if (isFirst)
|
|
{
|
|
isFirst = false;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
orderedBaseQuery = orderedBaseQuery.SpecialThenBy(sortOrder.Property, sortOrder.SortDirection);
|
|
}
|
|
}
|
|
var list = await orderedBaseQuery.ThenBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
else
|
|
{
|
|
var list = await baseQuery.OrderBy(c => c.StartDate).ThenBy(c => c.Location.Distance(location)).Skip(skip).Take(take).ToListAsync().ConfigureAwait(false);
|
|
return (total, list);
|
|
}
|
|
}
|
|
|
|
/// <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>
|
|
public async Task<PublicWalkRequestWithNames> GetWithNamesAsync(string id)
|
|
{
|
|
var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_PublicWalkRequestWithNames()", c => c.Id == id);
|
|
return await baseQuery.FirstOrDefaultAsync().ConfigureAwait(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setzt öffntliche 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>
|
|
public async Task<int> SetTimedOutAsync(DateTimeOffset date)
|
|
{
|
|
var requests = await Repository.FindAsync(c => c.ExpirationDate <= date && c.Deleted == false && c.Status == PublicWalkRequestStatus.Open).ConfigureAwait(false);
|
|
foreach (var request in requests)
|
|
{
|
|
request.Status = PublicWalkRequestStatus.TimedOut;
|
|
request.UpdatedAt = DateTimeOffset.UtcNow;
|
|
|
|
var responses = await _responsesRepository.FindAsync(c => c.PublicWalkRequestId == request.Id).ConfigureAwait(false);
|
|
foreach (var response in responses)
|
|
{
|
|
response.Status = PublicWalkResponseStatus.Closed;
|
|
response.UpdatedAt = DateTimeOffset.UtcNow;
|
|
}
|
|
}
|
|
|
|
return requests.Count();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zurücksetzen einer öffentlichen Anfrage
|
|
/// </summary>
|
|
/// <param name="id">Id der öffentlichen Anfrage</param>
|
|
/// <returns>true wenn erfolgreich, false sonst</returns>
|
|
public async Task<bool> ResetAsync(string id)
|
|
{
|
|
var request = await Repository.FirstOrDefaultAsync(c => c.Id == id);
|
|
if (request != null && request.Deleted == false && request.Status == PublicWalkRequestStatus.Placed)
|
|
{
|
|
request.Status = PublicWalkRequestStatus.Open;
|
|
request.PlacedDate = null;
|
|
request.PublicWalkResponseId = string.Empty;
|
|
request.DogWalkerId = string.Empty;
|
|
request.UpdatedAt = DateTimeOffset.UtcNow;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <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>
|
|
public async Task<List<PublicWalkRequest>> GetByStatusAsync(string dogOwnerId, PublicWalkRequestStatus status)
|
|
{
|
|
var requests = await Repository.FindAsync(c => c.DogOwnerId == dogOwnerId && c.Status == status && c.Deleted == false).ConfigureAwait(false);
|
|
return requests.ToList();
|
|
}
|
|
|
|
/// <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>
|
|
public IQueryable<PublicWalkRequestWithNames> FilterPublicWalkRequestsWithNames(string filter, bool includeDeleted)
|
|
{
|
|
var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_PublicWalkRequestWithNames()", c => c.DogOwnerName.Contains(filter) || c.PickupAddress_City.Contains(filter));
|
|
|
|
if (!includeDeleted)
|
|
baseQuery = baseQuery.Where(c => c.Deleted == false);
|
|
|
|
return baseQuery;
|
|
}
|
|
|
|
#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>
|
|
public PublicWalkRequestNotification CreateNotification(string publicWalkRequestId, string dogOwnerId, Address pickupAddress, Point location)
|
|
{
|
|
var item = new PublicWalkRequestNotification
|
|
{
|
|
PublicWalkRequestId = publicWalkRequestId,
|
|
DogOwnerId = dogOwnerId,
|
|
SentDate = null,
|
|
SentCount = 0,
|
|
HasBeenSent = false,
|
|
Created = DateTimeOffset.UtcNow,
|
|
PickupAddress =
|
|
{
|
|
AddressLine1 = pickupAddress.AddressLine1,
|
|
AddressLine2 = pickupAddress.AddressLine2,
|
|
Zip = pickupAddress.Zip,
|
|
City = pickupAddress.City,
|
|
CountryCode = pickupAddress.CountryCode,
|
|
State = pickupAddress.State
|
|
},
|
|
Location = location
|
|
};
|
|
|
|
return item;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hinzufügen einer Benachrichtigung
|
|
/// </summary>
|
|
/// <param name="publicWalkRequestNotification">Benachrichtigungs-Objekt</param>
|
|
public void AddNotification(PublicWalkRequestNotification publicWalkRequestNotification)
|
|
{
|
|
_notificationsRepository.Add(publicWalkRequestNotification);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt eine Liste von zu sendenden Benachrichtigungen zurück
|
|
/// </summary>
|
|
/// <returns>Liste zu sendende Benachrichtigungen</returns>
|
|
public async Task<List<PublicWalkRequestNotification>> GetNotificationsToSendAsync()
|
|
{
|
|
var notifications = await _notificationsRepository.FindAsync(c => c.HasBeenSent == false && c.SentDate == null).ConfigureAwait(false);
|
|
return notifications.ToList();
|
|
}
|
|
|
|
/// <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>
|
|
public async Task<int> CountByCreationDateAsync(DateTimeOffset startDate, DateTimeOffset endDate, string dogOwnerId, PublicWalkRequestStatus maxStatus)
|
|
{
|
|
var count = await Repository.CountAsync(c => c.DogOwnerId == dogOwnerId && c.Created >= startDate && c.Created <= endDate && c.Status <= maxStatus).ConfigureAwait(false);
|
|
return count;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|