843 lines
39 KiB
C#
843 lines
39 KiB
C#
using gehGassiApp.Core.Interfaces;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using gehGassi.Dto;
|
|
using gehGassi.Dto.Common;
|
|
using gehGassiApp.Core.Data;
|
|
using gehGassiApp.Core.Helper;
|
|
using gehGassiApp.Domain.Users;
|
|
using gehGassiApp.Core.Interfaces.Synchronization;
|
|
using gehGassiApp.Core.Mapper;
|
|
using gehGassiApp.Domain.Common;
|
|
using gehGassiApp.Core.Services.Synchronization;
|
|
using gehGassiApp.Core.Resources;
|
|
using gehGassi.Dto.Reporting;
|
|
|
|
namespace gehGassiApp.Core.Services
|
|
{
|
|
/// <summary>
|
|
/// Service der die Verwaltung des Benutzers ermöglicht
|
|
/// </summary>
|
|
public class UserService : ServiceBase<User>, IUserService
|
|
{
|
|
private readonly ICommunicationService _communicationService;
|
|
private readonly ISyncInfoPushService _pushService;
|
|
private readonly ISyncInfoPullService _pullService;
|
|
private readonly IRepository<AppUser> _appUserRepository;
|
|
|
|
/// <summary>
|
|
/// Erstellt eine Instanz
|
|
/// </summary>
|
|
/// <param name="unitOfWork">Instanz eines IUnitOfWork</param>
|
|
/// <param name="communicationService">Instanz eines ICommunicationService</param>
|
|
/// <param name="pushService">Instanz eines ISyncInfoPushService</param>
|
|
/// <param name="pullService">Instanz eines ISyncInfoPullService</param>
|
|
public UserService(IUnitOfWork unitOfWork, ICommunicationService communicationService, ISyncInfoPushService pushService, ISyncInfoPullService pullService) : base(unitOfWork)
|
|
{
|
|
_communicationService = communicationService;
|
|
_pushService = pushService;
|
|
_pullService = pullService;
|
|
_appUserRepository = unitOfWork.GetRepository<AppUser>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt eine Entität anhand der eindeutigen Id zurück
|
|
/// </summary>
|
|
/// <param name="id">Id der Entität</param>
|
|
/// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
|
|
/// <returns>Entität oder null, wenn nicht gefunden</returns>
|
|
public override User Get(object id, bool noTracking = true)
|
|
{
|
|
//Bewusst nicht implementiert
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt eine Entität anhand der eindeutigen Id zurück
|
|
/// </summary>
|
|
/// <param name="id">Id der Entität</param>
|
|
/// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
|
|
/// <returns>Entität oder null, wenn nicht gefunden</returns>
|
|
public override async Task<User> GetAsync(object id, bool noTracking = true)
|
|
{
|
|
//Bewusst nicht implementiert
|
|
await Task.Delay(1);
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt den aktuellen Benutzer zurück
|
|
/// </summary>
|
|
/// <returns>Aktueller Benutzer oder null, wenn noch keiner vorhanden</returns>
|
|
public async Task<User> GetAsync()
|
|
{
|
|
var user = await Repository.FirstOrDefaultAsync(c => c.Id != "", false).ConfigureAwait(false);
|
|
return user;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hinzufügen oder aktualisieren des Benutzers
|
|
/// </summary>
|
|
/// <param name="user">Benutzer der hinzugefügt oder aktualisiert werden soll</param>
|
|
/// <returns></returns>
|
|
public async Task<User> CreateOrUpdateAsync(User user)
|
|
{
|
|
var foundUser = await GetAsync().ConfigureAwait(false);
|
|
if (foundUser == null)
|
|
{
|
|
Repository.Add(user);
|
|
await CommitAsync();
|
|
return user;
|
|
}
|
|
foundUser.FirstName = user.FirstName;
|
|
foundUser.LastName = user.LastName;
|
|
foundUser.Roles = user.Roles;
|
|
foundUser.Photo = user.Photo;
|
|
foundUser.RegistrationDate = user.RegistrationDate;
|
|
foundUser.LastLoginDate = user.LastLoginDate;
|
|
foundUser.AppUserId = user.AppUserId;
|
|
|
|
Repository.Update(foundUser);
|
|
|
|
await CommitAsync().ConfigureAwait(false);
|
|
return foundUser;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prüft für einen übergebenen Benutzernamen ob es sich um den gespeicherten Benutzer handelt
|
|
/// </summary>
|
|
/// <param name="userName">Benutzername (E-Mail Adresse)</param>
|
|
/// <returns>UserCheckResult</returns>
|
|
public async Task<UserCheckResult> CheckAsync(string userName)
|
|
{
|
|
var user = await Repository.FirstOrDefaultAsync(c => c.Id != "", true).ConfigureAwait(false);
|
|
if (user != null)
|
|
{
|
|
return string.Equals(user.UserName, userName, StringComparison.CurrentCultureIgnoreCase) ? UserCheckResult.IsCurrentUser : UserCheckResult.IsOtherUser;
|
|
}
|
|
|
|
return UserCheckResult.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt den aktuellen App-User zurück.
|
|
/// </summary>
|
|
/// <returns>AppUser oder null wenn nicht gefunden</returns>
|
|
public async Task<AppUser> GetAppUserAsync()
|
|
{
|
|
var appUser = await _appUserRepository.FirstOrDefaultAsync(c => c.Id != "").ConfigureAwait(false);
|
|
return appUser;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt den aktuellen App-User zurück.
|
|
/// </summary>
|
|
/// <param name="noTracking">Tracking</param>
|
|
/// <returns>AppUser oder null wenn nicht gefunden</returns>
|
|
public async Task<AppUser> GetAppUserAsync(bool noTracking)
|
|
{
|
|
var appUser = await _appUserRepository.FirstOrDefaultAsync(c => c.Id != "", noTracking).ConfigureAwait(false);
|
|
return appUser;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt den aktuellen App-User zurück
|
|
/// Versucht auch online - wenn lokal nicht vorhanden
|
|
/// </summary>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <param name="forceOnline">Wenn true, wird in jedem Fall die Online-Abfrage verwendet</param>
|
|
/// <returns>AppUser oder null wenn nicht gefunden</returns>
|
|
public async Task<AppUser> GetAppUserAsync(string accessToken, CancellationToken token, bool forceOnline)
|
|
{
|
|
//Zuerst DB
|
|
if (forceOnline)
|
|
{
|
|
var isConnected = await _communicationService.IsConnected();
|
|
if (isConnected)
|
|
{
|
|
var appUserResult = await _communicationService.GetAppUserAsync(accessToken, token);
|
|
if (appUserResult.Success)
|
|
{
|
|
var appUserUpdated = await CreateOrUpdateAppUserAsync(appUserResult.Value);
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), DateTimeOffset.UtcNow);
|
|
return appUserUpdated;
|
|
}
|
|
}
|
|
}
|
|
|
|
var appUser = await _appUserRepository.FirstOrDefaultAsync(c => c.Id != "").ConfigureAwait(false);
|
|
if (appUser != null)
|
|
return appUser;
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hinzufügen oder aktualisieren eines App-Users
|
|
/// </summary>
|
|
/// <param name="appUser">App-User</param>
|
|
/// <returns>AppUser</returns>
|
|
public async Task<AppUser> CreateOrUpdateAppUserAsync(AppUser appUser)
|
|
{
|
|
var foundUser = await _appUserRepository.FirstOrDefaultAsync(c => c.Id != "", false).ConfigureAwait(false);
|
|
if (foundUser == null)
|
|
{
|
|
_appUserRepository.Add(appUser);
|
|
await CommitAsync();
|
|
return appUser;
|
|
}
|
|
|
|
if (appUser.UpdatedAt > foundUser.UpdatedAt)
|
|
{
|
|
foundUser.Type = appUser.Type;
|
|
foundUser.Title = appUser.Title;
|
|
foundUser.FirstName = appUser.FirstName;
|
|
foundUser.LastName = appUser.LastName;
|
|
foundUser.Sex = appUser.Sex;
|
|
foundUser.BirthDate = appUser.BirthDate;
|
|
foundUser.Photo = appUser.Photo;
|
|
foundUser.Contact = appUser.Contact;
|
|
foundUser.Address = appUser.Address;
|
|
foundUser.Lat = appUser.Lat;
|
|
foundUser.Lng = appUser.Lng;
|
|
foundUser.SocialMedia = appUser.SocialMedia;
|
|
foundUser.Locked = appUser.Locked;
|
|
foundUser.LockedUntil = appUser.LockedUntil;
|
|
foundUser.UpdatedAt = appUser.UpdatedAt;
|
|
foundUser.Deleted = appUser.Deleted;
|
|
foundUser.TermsAccepted = appUser.TermsAccepted;
|
|
foundUser.TermsAcceptedDate = appUser.TermsAcceptedDate;
|
|
foundUser.PrivacyAccepted = appUser.PrivacyAccepted;
|
|
foundUser.PrivacyAcceptedDate = appUser.PrivacyAcceptedDate;
|
|
foundUser.PaymentTermsAccepted = appUser.PaymentTermsAccepted;
|
|
foundUser.PaymentTermsAcceptedDate = appUser.PaymentTermsAcceptedDate;
|
|
foundUser.NationalityCode = appUser.NationalityCode ?? string.Empty;
|
|
foundUser.MainResidenceCode = appUser.MainResidenceCode ?? string.Empty;
|
|
foundUser.PaymentId = appUser.PaymentId;
|
|
foundUser.KycPassed = appUser.KycPassed;
|
|
foundUser.KycPassedDate = appUser.KycPassedDate;
|
|
foundUser.Verified = appUser.Verified;
|
|
foundUser.VerifiedDate = appUser.VerifiedDate;
|
|
foundUser.AutoPayout = appUser.AutoPayout;
|
|
|
|
_appUserRepository.Update(foundUser);
|
|
var changes = await CommitAsync().ConfigureAwait(false);
|
|
}
|
|
|
|
return await GetAppUserAsync();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aktualisieren eines App-Users.
|
|
/// Online wird versucht. Wenn nicht möglich wird ein Delta erstellt.
|
|
/// </summary>
|
|
/// <param name="appUser">App-User</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>App-User</returns>
|
|
public async Task<AppUser> UpdateAppUserAsync(AppUser appUser, string accessToken, CancellationToken token)
|
|
{
|
|
//Zuerst in der DB aktualisieren
|
|
|
|
var foundUser = await _appUserRepository.FirstOrDefaultAsync(c => c.Id == appUser.Id, false);
|
|
foundUser.FirstName = appUser.FirstName;
|
|
foundUser.LastName = appUser.LastName;
|
|
foundUser.Sex = appUser.Sex;
|
|
foundUser.BirthDate = appUser.BirthDate;
|
|
foundUser.Photo = appUser.Photo;
|
|
foundUser.Contact.Mobile = appUser.Contact.Mobile;
|
|
foundUser.Contact.Phone = appUser.Contact.Phone;
|
|
foundUser.Address.AddressLine1 = appUser.Address.AddressLine1;
|
|
foundUser.Address.AddressLine2 = appUser.Address.AddressLine2;
|
|
foundUser.Address.Zip = appUser.Address.Zip;
|
|
foundUser.Address.City = appUser.Address.City;
|
|
foundUser.Address.State = appUser.Address.State;
|
|
foundUser.Address.CountryCode = appUser.Address.CountryCode;
|
|
foundUser.NationalityCode = appUser.NationalityCode ?? string.Empty;
|
|
foundUser.MainResidenceCode = appUser.MainResidenceCode ?? string.Empty;
|
|
foundUser.AutoPayout = appUser.AutoPayout;
|
|
foundUser.UpdatedAt = DateTimeOffset.UtcNow;
|
|
if (appUser.Lat != 0 && appUser.Lng != 0)
|
|
{
|
|
foundUser.Lat = appUser.Lat;
|
|
foundUser.Lng = appUser.Lng;
|
|
}
|
|
|
|
_appUserRepository.Update(foundUser);
|
|
|
|
await CommitAsync().ConfigureAwait(false);
|
|
|
|
var appUserDto = foundUser.ToDto();
|
|
var photoFileName = string.Empty;
|
|
byte[] photo = null;
|
|
if (!string.IsNullOrWhiteSpace(foundUser.Photo))
|
|
{
|
|
if (!foundUser.Photo.StartsWithHttp())
|
|
{
|
|
//Datei laden und in byte array umwandeln
|
|
if (File.Exists(foundUser.Photo))
|
|
{
|
|
await using var stream = File.OpenRead(foundUser.Photo);
|
|
using var memoryStream = new MemoryStream();
|
|
await stream.CopyToAsync(memoryStream, token);
|
|
photo = memoryStream.ToArray();
|
|
photoFileName = Path.GetFileName(appUserDto.Photo);
|
|
}
|
|
}
|
|
}
|
|
|
|
var isConnected = await _communicationService.IsConnected();
|
|
if (isConnected)
|
|
{
|
|
var updateResult = await _communicationService.UpdateAppUserAsync(appUserDto,photoFileName,photo,accessToken, token);
|
|
if (updateResult.Success)
|
|
{
|
|
//Alles gut nichts weglegen
|
|
//Für den Pull-Service das Update-Datum setzen
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), foundUser.UpdatedAt).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
//Weglegen und später versuchen
|
|
await _pushService.AddAsync(nameof(AppUser), foundUser.Id, SyncOperation.Edit, foundUser).ConfigureAwait(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Weglegen und später versuchen
|
|
await _pushService.AddAsync(nameof(AppUser), foundUser.Id, SyncOperation.Edit, foundUser).ConfigureAwait(false);
|
|
}
|
|
|
|
return foundUser;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setzen des App-User Types für einen AppUser.
|
|
/// Immer online und nur wenn erfolgreich auch ein Update lokal!
|
|
/// </summary>
|
|
/// <param name="appUserId">Id des AppUsers</param>
|
|
/// <param name="appUserType">Typ der gesetzt werden soll</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>CommunicationResult</returns>
|
|
public async Task<CommunicationResult<bool>> SetAppUserTypeAsync(string appUserId, AppUserType appUserType, string accessToken, CancellationToken token)
|
|
{
|
|
var result = new CommunicationResult<bool>();
|
|
|
|
var hasConnection = await _communicationService.IsConnected();
|
|
if (hasConnection)
|
|
{
|
|
var model = new SetAppUserTypeDto()
|
|
{
|
|
Id = appUserId,
|
|
Type = (AppUserTypeDto)appUserType,
|
|
UpdatedAt = DateTimeOffset.UtcNow
|
|
};
|
|
|
|
var serverResult = await _communicationService.SetAppUserTypeAsync(model, accessToken, token);
|
|
if (serverResult.Success && serverResult.Value)
|
|
{
|
|
//jetzt auch lokal die Änderung speichern
|
|
var appUser = await GetAppUserAsync(false);
|
|
appUser.Type = appUserType;
|
|
appUser.UpdatedAt = model.UpdatedAt;
|
|
_appUserRepository.Update(appUser);
|
|
await CommitAsync().ConfigureAwait(false);
|
|
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), model.UpdatedAt);
|
|
}
|
|
|
|
return serverResult;
|
|
}
|
|
else
|
|
{
|
|
result.Success = false;
|
|
result.ErrorCode = CommunicationErrors.ServerNoConnection;
|
|
result.ErrorMessage = Errors.Server_NoConnection;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setzen des App-User Types für einen AppUser.
|
|
/// Immer online und nur wenn erfolgreich auch ein Update lokal!
|
|
/// </summary>
|
|
/// <param name="appUserId">Id des AppUsers</param>
|
|
/// <param name="appUserType">Typ der gesetzt werden soll</param>
|
|
/// <param name="nationality">Nationalität</param>
|
|
/// <param name="mainResidence">Land des Hauptwohnsitzes</param>
|
|
/// <param name="paymentTermsAccepted">AGB Paymentprovider akzeptiert</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>CommunicationResult</returns>
|
|
public async Task<CommunicationResult<bool>> SetAppUserTypeAsync(string appUserId, AppUserType appUserType, string nationality, string mainResidence, bool paymentTermsAccepted, string accessToken, CancellationToken token)
|
|
{
|
|
var result = new CommunicationResult<bool>();
|
|
|
|
var hasConnection = await _communicationService.IsConnected();
|
|
if (hasConnection)
|
|
{
|
|
var model = new SetAppUserTypeExDto()
|
|
{
|
|
Id = appUserId,
|
|
Type = (AppUserTypeDto)appUserType,
|
|
NationalityCode = nationality,
|
|
MainResidenceCode = mainResidence,
|
|
PaymentTermsAccepted = paymentTermsAccepted,
|
|
PaymentTermsAcceptedDate = DateTimeOffset.UtcNow,
|
|
UpdatedAt = DateTimeOffset.UtcNow
|
|
};
|
|
|
|
var serverResult = await _communicationService.SetAppUserTypeAsync(model, accessToken, token);
|
|
if (serverResult.Success && serverResult.Value != null)
|
|
{
|
|
//jetzt auch lokal die Änderung speichern
|
|
var appUser = await GetAppUserAsync(false);
|
|
appUser.Type = appUserType;
|
|
appUser.NationalityCode = serverResult.Value.NationalityCode;
|
|
appUser.MainResidenceCode = serverResult.Value.MainResidenceCode;
|
|
appUser.PaymentTermsAccepted = serverResult.Value.PaymentTermsAccepted;
|
|
appUser.PaymentTermsAcceptedDate = serverResult.Value.PaymentTermsAcceptedDate;
|
|
appUser.PaymentId = serverResult.Value.PaymentId;
|
|
appUser.UpdatedAt = model.UpdatedAt;
|
|
_appUserRepository.Update(appUser);
|
|
await CommitAsync().ConfigureAwait(false);
|
|
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), model.UpdatedAt);
|
|
|
|
result.Success = true;
|
|
result.Value = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.Success = false;
|
|
result.ErrorCode = CommunicationErrors.ServerNoConnection;
|
|
result.ErrorMessage = Errors.Server_NoConnection;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hinzufügen eines Payment-Users. Für Hundebesitzer wenn sie noch keine PaymentId haben
|
|
/// </summary>
|
|
/// <param name="appUserId">Id des AppUsers</param>
|
|
/// <param name="nationality">Nationalität</param>
|
|
/// <param name="mainResidence">Land des Hauptwohnsitzes</param>
|
|
/// <param name="paymentTermsAccepted">AGB Paymentprovider akzeptiert</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>CommunicationResult</returns>
|
|
public async Task<CommunicationResult<bool>> AddPaymentUserAsync(string appUserId, string nationality, string mainResidence, bool paymentTermsAccepted, string accessToken, CancellationToken token)
|
|
{
|
|
var result = new CommunicationResult<bool>();
|
|
|
|
var hasConnection = await _communicationService.IsConnected();
|
|
if (hasConnection)
|
|
{
|
|
var model = new AddPaymentUserDto()
|
|
{
|
|
Id = appUserId,
|
|
NationalityCode = nationality,
|
|
MainResidenceCode = mainResidence,
|
|
PaymentTermsAccepted = paymentTermsAccepted,
|
|
PaymentTermsAcceptedDate = DateTimeOffset.UtcNow
|
|
};
|
|
|
|
var serverResult = await _communicationService.AddPaymentUserAsync(model, accessToken, token);
|
|
if (serverResult.Success && serverResult.Value != null)
|
|
{
|
|
//jetzt auch lokal die Änderung speichern
|
|
var appUser = await GetAppUserAsync(false);
|
|
appUser.NationalityCode = serverResult.Value.NationalityCode;
|
|
appUser.MainResidenceCode = serverResult.Value.MainResidenceCode;
|
|
appUser.PaymentTermsAccepted = serverResult.Value.PaymentTermsAccepted;
|
|
appUser.PaymentTermsAcceptedDate = serverResult.Value.PaymentTermsAcceptedDate;
|
|
appUser.PaymentId = serverResult.Value.PaymentId;
|
|
appUser.UpdatedAt = serverResult.Value.UpdatedAt;
|
|
_appUserRepository.Update(appUser);
|
|
await CommitAsync().ConfigureAwait(false);
|
|
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), appUser.UpdatedAt);
|
|
|
|
result.Success = true;
|
|
result.Value = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.Success = false;
|
|
result.ErrorCode = CommunicationErrors.ServerNoConnection;
|
|
result.ErrorMessage = Errors.Server_NoConnection;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setzen der Bankverbindungs-ID für einen AppUser.
|
|
/// </summary>
|
|
/// <param name="appUserId">Id des App-Users</param>
|
|
/// <param name="bankId">ID der Bankverbindung</param>
|
|
/// <param name="updatedAt">Datum letzte Aktualisierung</param>
|
|
/// <returns>App-User</returns>
|
|
public async Task<AppUser> SetBankAccountAsync(string appUserId, string bankId, DateTimeOffset updatedAt)
|
|
{
|
|
var appUser = await GetAppUserAsync(false);
|
|
appUser.BankId = bankId;
|
|
appUser.UpdatedAt = updatedAt;
|
|
_appUserRepository.Update(appUser);
|
|
await CommitAsync().ConfigureAwait(false);
|
|
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), appUser.UpdatedAt);
|
|
|
|
return appUser;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Blockieren eines App-Users am Server
|
|
/// </summary>
|
|
/// <param name="appUserId">Id des App-Users der die Blockierung vornimmt</param>
|
|
/// <param name="blockedAppUserId">Id des App-Users der blockiert wird</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>CommunicationResult</returns>
|
|
public async Task<CommunicationResult<bool>> BlockAppUserAsync(string appUserId, string blockedAppUserId, string accessToken, CancellationToken token)
|
|
{
|
|
var result = new CommunicationResult<bool>();
|
|
|
|
var hasConnection = await _communicationService.IsConnected();
|
|
if (hasConnection)
|
|
{
|
|
var model = new BlockCreateDto()
|
|
{
|
|
BlockingAppUserId = appUserId,
|
|
BlockedAppUserId = blockedAppUserId
|
|
};
|
|
|
|
var serverResult = await _communicationService.BlockAppUserAsync(model, accessToken, token);
|
|
return serverResult;
|
|
}
|
|
else
|
|
{
|
|
result.Success = false;
|
|
result.ErrorCode = CommunicationErrors.ServerNoConnection;
|
|
result.ErrorMessage = Errors.Server_NoConnection;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aufheben der Blockierung eines App-Users am Server
|
|
/// </summary>
|
|
/// <param name="appUserId">Id des App-Users der die Blockierung vorgenommen hat</param>
|
|
/// <param name="blockedAppUserId">Id des App-Users dessen Blockierung aufgehoben wird</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>CommunicationResult</returns>
|
|
public async Task<CommunicationResult<bool>> UnblockAppUserAsync(string appUserId, string blockedAppUserId, string accessToken, CancellationToken token)
|
|
{
|
|
var result = new CommunicationResult<bool>();
|
|
|
|
var hasConnection = await _communicationService.IsConnected();
|
|
if (hasConnection)
|
|
{
|
|
var model = new BlockRemoveDto()
|
|
{
|
|
BlockingAppUserId = appUserId,
|
|
BlockedAppUserId = blockedAppUserId
|
|
};
|
|
|
|
var serverResult = await _communicationService.UnblockAppUserAsync(model, accessToken, token);
|
|
return serverResult;
|
|
}
|
|
else
|
|
{
|
|
result.Success = false;
|
|
result.ErrorCode = CommunicationErrors.ServerNoConnection;
|
|
result.ErrorMessage = Errors.Server_NoConnection;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Holen von blockierten App-Usern
|
|
/// </summary>
|
|
/// <param name="query">Abfrageobjekt</param>
|
|
/// <param name="location">Aktuelle Position</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>ListCommunicationResult</returns>
|
|
public async Task<ListCommunicationResult<List<AppUserBlockWithNames>>> GetBlockedAppUsersAsync(BlockedQueryDto query, LocationDto location, string accessToken, CancellationToken token)
|
|
{
|
|
var result = new ListCommunicationResult<List<AppUserBlockWithNames>>() { Value = new List<AppUserBlockWithNames>() };
|
|
|
|
var isConnected = await _communicationService.IsConnected();
|
|
if (isConnected)
|
|
{
|
|
query.Location = location;
|
|
|
|
var queryResult = await _communicationService.GetBlockedAppUsersAsync(query, accessToken, token);
|
|
if (queryResult.Success && queryResult.Value.Count >= 1)
|
|
{
|
|
return queryResult;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.Success = false;
|
|
result.ErrorCode = CommunicationErrors.ServerNoConnection;
|
|
result.ErrorMessage = Errors.Server_NoConnection;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Melden eines App-Users durch einen anderen bei Verfehlungen oder anstößigen Inhalten
|
|
/// </summary>
|
|
/// <param name="appUserId">Id des App-Users der die Meldung vornimmt</param>
|
|
/// <param name="reportedAppUserId">Id des App-Users der gemeldet wird</param>
|
|
/// <param name="section">Betroffener Bereich</param>
|
|
/// <param name="sectionId">Id des Bereichs</param>
|
|
/// <param name="sectionId2">Optional: zweite Id falls nötig</param>
|
|
/// <param name="reportedImage">Bild beanstanded</param>
|
|
/// <param name="reportedName">Name beanstanded</param>
|
|
/// <param name="reportedText">Text beanstanded</param>
|
|
/// <param name="reportedMessage">Nachricht beanstanded</param>
|
|
/// <param name="reportedAddress">Adresse beanstanded</param>
|
|
/// <param name="type">Typ der Meldung</param>
|
|
/// <param name="email">Email-Adresse des meldenen Benutzers für Kontaktaufnahme</param>
|
|
/// <param name="comment">Anmerkungen des meldenden Benutzers</param>
|
|
/// <param name="message">Chat-Nachricht wenn es eine betrifft</param>
|
|
/// <param name="blockType">Art der bBlockierung</param>
|
|
/// <param name="contactAllowed">Darf für Rückfragen kontaktiert werden</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>ListCommunicationResult</returns>
|
|
public async Task<CommunicationResult<bool>> ReportAppUserAsync(string appUserId, string reportedAppUserId, AppUserReportSection section, string sectionId, string sectionId2,
|
|
bool reportedImage, bool reportedName, bool reportedText, bool reportedMessage, bool reportedAddress, AppUserReportType type, string email, string comment, string message, AppUserReportBlockType blockType, bool contactAllowed,
|
|
string accessToken, CancellationToken token)
|
|
{
|
|
var result = new CommunicationResult<bool>();
|
|
|
|
var hasConnection = await _communicationService.IsConnected();
|
|
if (hasConnection)
|
|
{
|
|
var model = new AppUserReportDto()
|
|
{
|
|
ReportingAppUserId = appUserId,
|
|
ReportedAppUserId = reportedAppUserId,
|
|
Section = section.ToDto(),
|
|
SectionId = sectionId,
|
|
SectionId2 = sectionId2,
|
|
ReportedImage = reportedImage,
|
|
ReportedName = reportedName,
|
|
ReportedText = reportedText,
|
|
ReportedMessage = reportedMessage,
|
|
ReportedAddress = reportedAddress,
|
|
Type = type.ToDto(),
|
|
Email = email,
|
|
Comment = comment,
|
|
Message = message,
|
|
BlockType = blockType.ToDto(),
|
|
ContactAllowed = contactAllowed
|
|
};
|
|
|
|
var serverResult = await _communicationService.ReportAppUserAsync(model, accessToken, token);
|
|
return serverResult;
|
|
}
|
|
else
|
|
{
|
|
result.Success = false;
|
|
result.ErrorCode = CommunicationErrors.ServerNoConnection;
|
|
result.ErrorMessage = Errors.Server_NoConnection;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Holen der Daten vom lokalen Speicher die noch nicht synchronisiert wurden und senden an den Server
|
|
/// </summary>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>Task</returns>
|
|
public async Task<SyncResult<AppUser>> PushAsync(string accessToken, CancellationToken token)
|
|
{
|
|
var result = new SyncResult<AppUser>();
|
|
|
|
if (await _pushService.HasOpenAsync(nameof(AppUser)) > 0)
|
|
{
|
|
var deltas = await _pushService.GetAllAsync(nameof(AppUser)).ConfigureAwait(false);
|
|
if (deltas.Any())
|
|
{
|
|
var isConnected = await _communicationService.IsConnected();
|
|
|
|
if (!isConnected) return result;
|
|
|
|
deltas = deltas.OrderBy(c => c.DateTime).ToList();
|
|
foreach (var syncInfoPush in deltas)
|
|
{
|
|
//Es gibt hier ur Update... daher alles andere ignorieren
|
|
if (syncInfoPush.Operation != SyncOperation.Edit)
|
|
{
|
|
await _pushService.RemoveAsync(syncInfoPush.Id).ConfigureAwait(false);
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(syncInfoPush.Value))
|
|
{
|
|
var appUser = JsonSerializer.Deserialize<AppUser>(syncInfoPush.Value, new JsonSerializerOptions(JsonSerializerDefaults.Web));
|
|
|
|
//Jetzt Update senden...
|
|
var appUserDto = appUser.ToDto();
|
|
var photoFileName = string.Empty;
|
|
byte[] photo = null;
|
|
if (!string.IsNullOrWhiteSpace(appUser.Photo))
|
|
{
|
|
if (!appUser.Photo.StartsWithHttp())
|
|
{
|
|
//Datei laden und in byte array umwandeln
|
|
if (File.Exists(appUser.Photo))
|
|
{
|
|
await using var stream = File.OpenRead(appUser.Photo);
|
|
using var memoryStream = new MemoryStream();
|
|
await stream.CopyToAsync(memoryStream, token);
|
|
photo = memoryStream.ToArray();
|
|
photoFileName = Path.GetFileName(appUserDto.Photo);
|
|
}
|
|
}
|
|
}
|
|
|
|
var updateResult = await _communicationService.UpdateAppUserAsync(appUserDto, photoFileName, photo, accessToken, token);
|
|
if (updateResult.Success)
|
|
{
|
|
//Aktualisierung durchgeführt.
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), appUser.UpdatedAt).ConfigureAwait(false);
|
|
await _pushService.RemoveAsync(syncInfoPush.Id).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
//TODO: Prüfen!!!!
|
|
//Derzeiut egal welcher Fehler vorliegt, weg damit
|
|
//Aktualisierung durchgeführt.
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), appUser.UpdatedAt).ConfigureAwait(false);
|
|
await _pushService.RemoveAsync(syncInfoPush.Id).ConfigureAwait(false);
|
|
}
|
|
//Else ist nichts tun, konnte nicht übertragen werden.
|
|
}
|
|
else
|
|
{
|
|
await _pushService.RemoveAsync(syncInfoPush.Id).ConfigureAwait(false);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine(ex.Message);
|
|
await _pushService.RemoveAsync(syncInfoPush.Id).ConfigureAwait(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Es gibt hier kein Push!
|
|
await Task.Delay(1);
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Holen der letzten Daten vom Server und Synchronisieren mit den lokalen Daten
|
|
/// </summary>
|
|
/// <param name="language">Sprache</param>
|
|
/// <param name="accessToken">Aktuelles Accesstoken</param>
|
|
/// <param name="token">CancellationToken</param>
|
|
/// <returns>Task</returns>
|
|
public async Task<SyncResult<AppUser>> PullAsync(string language, string accessToken, CancellationToken token)
|
|
{
|
|
var result = new SyncResult<AppUser>();
|
|
|
|
//Zuerst immer online...
|
|
var isConnected = await _communicationService.IsConnected();
|
|
|
|
if (isConnected)
|
|
{
|
|
//Zuerst lezte Aktivität holen...
|
|
DateTimeOffset? lastUpdate = null;
|
|
var lastSyncInfo = await _pullService.GetAsync(nameof(AppUser)).ConfigureAwait(false);
|
|
if (lastSyncInfo != null)
|
|
lastUpdate = lastSyncInfo.LastUpdate;
|
|
|
|
var ctsQuery = new CancellationTokenSource(Common.Constants.PushPullTimeout);
|
|
var appUserResult = await _communicationService.GetAppUserSyncAsync(lastUpdate, accessToken, token);
|
|
if (appUserResult.Success)
|
|
{
|
|
if (appUserResult.Value != null)
|
|
{
|
|
var appUser = await _appUserRepository.GetAsync(appUserResult.Value.Id).ConfigureAwait(false);
|
|
if (appUser != null)
|
|
{
|
|
appUser.FirstName = appUserResult.Value.FirstName;
|
|
appUser.LastName = appUserResult.Value.LastName;
|
|
appUser.Sex = appUserResult.Value.Sex;
|
|
appUser.BirthDate = appUserResult.Value.BirthDate;
|
|
appUser.Photo = appUserResult.Value.Photo;
|
|
appUser.Contact.Mobile = appUserResult.Value.Contact.Mobile;
|
|
appUser.Contact.Phone = appUserResult.Value.Contact.Phone;
|
|
appUser.Address.AddressLine1 = appUserResult.Value.Address.AddressLine1;
|
|
appUser.Address.AddressLine2 = appUserResult.Value.Address.AddressLine2;
|
|
appUser.Address.Zip = appUserResult.Value.Address.Zip;
|
|
appUser.Address.City = appUserResult.Value.Address.City;
|
|
appUser.Address.State = appUserResult.Value.Address.State;
|
|
appUser.Address.CountryCode = appUserResult.Value.Address.CountryCode;
|
|
appUser.Lat = appUserResult.Value.Lat;
|
|
appUser.Lng = appUserResult.Value.Lng;
|
|
appUser.Type = appUserResult.Value.Type;
|
|
appUser.TermsAccepted = appUserResult.Value.TermsAccepted;
|
|
appUser.TermsAcceptedDate = appUserResult.Value.TermsAcceptedDate;
|
|
appUser.PrivacyAccepted = appUserResult.Value.PrivacyAccepted;
|
|
appUser.PrivacyAcceptedDate = appUserResult.Value.PrivacyAcceptedDate;
|
|
appUser.PaymentTermsAccepted = appUserResult.Value.PaymentTermsAccepted;
|
|
appUser.PaymentTermsAcceptedDate = appUserResult.Value.PaymentTermsAcceptedDate;
|
|
appUser.NationalityCode = appUserResult.Value.NationalityCode;
|
|
appUser.MainResidenceCode = appUserResult.Value.MainResidenceCode;
|
|
appUser.PaymentId = appUserResult.Value.PaymentId;
|
|
appUser.KycPassed = appUserResult.Value.KycPassed;
|
|
appUser.KycPassedDate = appUserResult.Value.KycPassedDate;
|
|
appUser.BankId = appUserResult.Value.BankId;
|
|
appUser.Verified = appUserResult.Value.Verified;
|
|
appUser.VerifiedDate = appUserResult.Value.VerifiedDate;
|
|
appUser.AutoPayout = appUserResult.Value.AutoPayout;
|
|
|
|
appUser.UpdatedAt = DateTimeOffset.UtcNow;
|
|
|
|
_appUserRepository.Update(appUser);
|
|
await CommitAsync().ConfigureAwait(false);
|
|
|
|
result.Updated.Add(appUser);
|
|
result.LastUpdate = appUserResult.Value.UpdatedAt;
|
|
await _pullService.AddOrUpddateAsync(nameof(AppUser), appUserResult.Value.UpdatedAt).ConfigureAwait(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
result.LastUpdate ??= lastUpdate;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|