602 lines
31 KiB
C#
602 lines
31 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Dynamic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using AutoMapper;
|
|
using gehGassi.Core.Interfaces;
|
|
using gehGassi.Core.Services;
|
|
using gehGassi.Domain.Common;
|
|
using gehGassi.Domain.Dogs;
|
|
using gehGassi.Domain.Users;
|
|
using gehGassi.Web.Auth;
|
|
using gehGassi.Web.Helper;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.Routing;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Localization;
|
|
using SixLabors.ImageSharp;
|
|
using SixLabors.ImageSharp.Advanced;
|
|
using SixLabors.ImageSharp.Processing;
|
|
|
|
namespace gehGassi.Web.Controllers
|
|
{
|
|
/// <summary>
|
|
/// Controller der Tools für CB zur Verfügung stellt
|
|
/// </summary>
|
|
[Authorize(Policy = Policies.AdministratorOnly)]
|
|
public class ToolsController : BaseController
|
|
{
|
|
private readonly IMapper _mapper;
|
|
private readonly IStringLocalizer<ToolsController> _localizer;
|
|
private readonly IFileService _fileService;
|
|
private readonly IFileShareService _fileShareService;
|
|
private readonly IMangoPayService _mangoPayService;
|
|
private readonly IPushNotificationService _pushNotificationService;
|
|
private readonly IAppUserService _appUserService;
|
|
private readonly IWalletService _walletService;
|
|
private readonly IWalkService _walkService;
|
|
private readonly IRatingService _ratingService;
|
|
private readonly ITransactionFeeService _transactionFeeService;
|
|
private readonly IRefreshTokenService _refreshTokenService;
|
|
private readonly IUserService _userService;
|
|
private readonly IFavouriteService _favouriteService;
|
|
private readonly ISystemMessageService _systemMessageService;
|
|
private readonly IDeviceService _deviceService;
|
|
private readonly IMessageService _messageService;
|
|
private readonly IAppUserReportService _appUserReportService;
|
|
|
|
/// <summary>
|
|
/// Erstellt eine Instanz
|
|
/// </summary>
|
|
/// <param name="mapper">Instanz eines IMapper</param>
|
|
/// <param name="localizer">Instanz eines IStringLocalizer</param>
|
|
/// <param name="fileService">Instanz eines IFileService</param>
|
|
/// <param name="fileShareService">Instanz eines IFileShareService</param>
|
|
/// <param name="mangoPayService">Instanz eines IMangoPayService</param>
|
|
/// <param name="pushNotificationService">Instanz eines IPushNotificationService</param>
|
|
/// <param name="appUserService">Instanz eines IAppUserService</param>
|
|
/// <param name="walletService">Instanz eines IWalletService</param>
|
|
/// <param name="walkService">Instanz eines IWalkService</param>
|
|
/// <param name="ratingService">Instanz eines IRatingService</param>
|
|
/// <param name="transactionFeeService">Instanz eines ITransactionFeeService</param>
|
|
/// <param name="refreshTokenService">Instanz eines IRefreshTokenService</param>
|
|
/// <param name="userService">Instanz eines IUserService</param>
|
|
/// <param name="favouriteService">Instanz eines IFavouriteService</param>
|
|
/// <param name="systemMessageService">Instanz eines ISystemMessageService</param>
|
|
/// <param name="deviceService">Instanz eines IDeviceService</param>
|
|
/// <param name="messageService">Instanz eines IMessageService</param>
|
|
/// <param name="appUserReportService">Instanz eines IAppUserReportService</param>
|
|
public ToolsController(IMapper mapper, IStringLocalizer<ToolsController> localizer, IFileService fileService, IFileShareService fileShareService, IMangoPayService mangoPayService, IPushNotificationService pushNotificationService,
|
|
IAppUserService appUserService, IWalletService walletService, IWalkService walkService, IRatingService ratingService, ITransactionFeeService transactionFeeService, IRefreshTokenService refreshTokenService,
|
|
IUserService userService, IFavouriteService favouriteService, ISystemMessageService systemMessageService, IDeviceService deviceService, IMessageService messageService, IAppUserReportService appUserReportService)
|
|
{
|
|
_mapper = mapper;
|
|
_localizer = localizer;
|
|
_fileService = fileService;
|
|
_fileShareService = fileShareService;
|
|
_mangoPayService = mangoPayService;
|
|
_pushNotificationService = pushNotificationService;
|
|
_appUserService = appUserService;
|
|
_walletService = walletService;
|
|
_walkService = walkService;
|
|
_ratingService = ratingService;
|
|
_transactionFeeService = transactionFeeService;
|
|
_refreshTokenService = refreshTokenService;
|
|
_userService = userService;
|
|
_favouriteService = favouriteService;
|
|
_systemMessageService = systemMessageService;
|
|
_deviceService = deviceService;
|
|
_messageService = messageService;
|
|
_appUserReportService = appUserReportService;
|
|
}
|
|
|
|
public async Task<IActionResult> TestMango()
|
|
{
|
|
await _mangoPayService.TestAsync();
|
|
|
|
//var userId = await _mangoPayService.CreateOwnerAsync("2d23b001907946eba8aaa46aa46ef8a6");
|
|
//var updateSuccess = await _mangoPayService.UpdateOwnerAsync("2d23b001907946eba8aaa46aa46ef8a6");
|
|
|
|
//var walletFees = await _mangoPayService.CreateWalletAsync("2d23b001907946eba8aaa46aa46ef8a6", WalletType.Fees);
|
|
//var walletCredits = await _mangoPayService.CreateWalletAsync("2d23b001907946eba8aaa46aa46ef8a6", WalletType.Credits);
|
|
|
|
//var balance1 = await _mangoPayService.GetBalanceAsync("2d23b001907946eba8aaa46aa46ef8a6", WalletType.Fees);
|
|
//var balance2 = await _mangoPayService.GetBalanceAsync("2d23b001907946eba8aaa46aa46ef8a6", WalletType.Credits);
|
|
|
|
//var balanceResult = await _mangoPayService.GetWalletBalanceAsync("162617747");
|
|
|
|
//var redirectUrl = await _mangoPayService.CreatePayInMaeostroAsync("162609301", "162617747", 10000);
|
|
|
|
return Ok();
|
|
//var redirectUrl = await _mangoPayService.CreatePayInMaeostroAsync("160864861", "160911719", 1000);
|
|
|
|
//return Redirect(redirectUrl);
|
|
}
|
|
|
|
public async Task<IActionResult> Hub()
|
|
{
|
|
await _pushNotificationService.ListRegistrationsAsync();
|
|
|
|
return Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hilfsmethode die alle Walks so einstellt, dass wir nach dem Lauch kein Problem mit Wallets und Transaktionen haben
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<IActionResult> PrepareWalksForLaunch()
|
|
{
|
|
//Publicwalk-Requests sollten kein Problem sein, da sie nur relevant sind, wenn Walks daraus erstellt wurden.
|
|
|
|
//1. Alle Walks holen die "nur" angefragt wurden
|
|
var walks = await _walkService.GetByStatusAsync(WalkStatus.Requested);
|
|
foreach (var walk in walks)
|
|
{
|
|
//Walks die angefragt wurden, aber noch nicht gestartet sind, werden auf "Storniert" gesetzt
|
|
walk.Status = WalkStatus.Cancelled;
|
|
walk.CancelledBy = CancellationSource.GehGassi;
|
|
walk.CancelledReason = "Prepare launch of gehgassi";
|
|
walk.UpdatedAt = DateTimeOffset.UtcNow;
|
|
await _walkService.CommitAsync("System");
|
|
}
|
|
|
|
//2. Alle Walks holen die "angenommen" wurden
|
|
walks = await _walkService.GetByStatusAsync(WalkStatus.Accepted);
|
|
foreach (var walk in walks)
|
|
{
|
|
walk.Status = WalkStatus.Cancelled;
|
|
walk.CancelledBy = CancellationSource.GehGassi;
|
|
walk.CancelledReason = "Prepare launch of gehgassi";
|
|
walk.UpdatedAt = DateTimeOffset.UtcNow;
|
|
if (walk.PaymentStatus == PaymentStatus.Paid || walk.PaymentStatus == PaymentStatus.Authorized)
|
|
{
|
|
//Zurücküberweisen der Summe vom Transaktionskonto auf das Guthabenkonto
|
|
if (walk.Price > 0)
|
|
{
|
|
var ammount = (long)(walk.Price * 100);
|
|
var tag = $"Walk_Cancel_{walk.Id}";
|
|
var refundResult = await _mangoPayService.TransferMoneyFromFeeToCreditAccountAsync(walk.DogOwnerId, ammount, tag);
|
|
if (refundResult.Success)
|
|
walk.PaymentStatus = PaymentStatus.Refunded;
|
|
else
|
|
walk.PaymentStatus = PaymentStatus.Voided;
|
|
}
|
|
else
|
|
walk.PaymentStatus = PaymentStatus.Voided;
|
|
}
|
|
await _walkService.CommitAsync("System");
|
|
}
|
|
|
|
//3. Alle Walks holen die "gestartet" wurden
|
|
walks = await _walkService.GetByStatusAsync(WalkStatus.Started);
|
|
foreach (var walk in walks)
|
|
{
|
|
walk.Status = WalkStatus.Completed;
|
|
walk.Completed = DateTimeOffset.UtcNow;
|
|
walk.UpdatedAt = DateTimeOffset.UtcNow;
|
|
walk.CompletedInfo = string.Empty;
|
|
walk.Defactation = true;
|
|
await _walkService.CommitAsync(User.Identity.Name);
|
|
|
|
//Rating erstellen
|
|
var appUser = await _appUserService.GetAsync(walk.DogOwnerId);
|
|
if (appUser != null)
|
|
{
|
|
var ratingTargetType = walk.ServiceType switch
|
|
{
|
|
WalkServiceType.Sitting => RatingTarget.Sitting,
|
|
WalkServiceType.DayCare => RatingTarget.DayCare,
|
|
_ => RatingTarget.Walk
|
|
};
|
|
|
|
var rating = _ratingService.Create(walk.DogWalkerId, appUser.Type, walk.Id, ratingTargetType, 5, string.Empty);
|
|
_ratingService.Add(rating);
|
|
|
|
//Neu: Rating für jeden der Hunde erstellen wenn es mehrere sind, oder halt einen wenn nur einer ist
|
|
var dogsList = JsonSerializer.Deserialize<List<DogWalkJson>>(walk.DogsJson, new JsonSerializerOptions(JsonSerializerDefaults.Web));
|
|
foreach (var dogWalkJson in dogsList)
|
|
{
|
|
var ratingDog = _ratingService.Create(walk.DogWalkerId, appUser.Type, dogWalkJson.Id, RatingTarget.Dog, 5, string.Empty);
|
|
_ratingService.Add(ratingDog);
|
|
}
|
|
|
|
await _ratingService.CommitAsync(User.Identity.Name);
|
|
|
|
//Rating-Statistik für Hunde / Hunde aktualisieren
|
|
foreach (var dogWalkJson in dogsList)
|
|
{
|
|
await _ratingService.UpdateRatingStatisticsAsync(dogWalkJson.Id, RatingTarget.Dog);
|
|
}
|
|
|
|
await _ratingService.CommitAsync(User.Identity.Name);
|
|
}
|
|
}
|
|
|
|
//4. Alle Walks holen die "abgeschlossen" wurden
|
|
walks = await _walkService.GetByStatusAsync(WalkStatus.Completed);
|
|
foreach (var walk in walks)
|
|
{
|
|
walk.Status = WalkStatus.Confirmed;
|
|
walk.Confirmed = DateTimeOffset.UtcNow;
|
|
walk.UpdatedAt = DateTimeOffset.UtcNow;
|
|
walk.PaymentStatus = PaymentStatus.Paid;
|
|
await _walkService.CommitAsync(User.Identity.Name);
|
|
|
|
//Zahlung veranlassen....
|
|
decimal feeDecimal = 0;
|
|
long fee = 0;
|
|
var gehGassiFee = await _transactionFeeService.GetMinGehGassiFeeAsync(walk.Price);
|
|
if (gehGassiFee != null)
|
|
{
|
|
if (gehGassiFee.Percent > 0)
|
|
{
|
|
var percent = walk.Price * gehGassiFee.Percent / 100;
|
|
feeDecimal = percent;
|
|
}
|
|
|
|
if (gehGassiFee.Fixed > 0)
|
|
{
|
|
feeDecimal += gehGassiFee.Fixed;
|
|
}
|
|
}
|
|
if (feeDecimal > 0)
|
|
{
|
|
fee = (long)(feeDecimal * 100);
|
|
}
|
|
|
|
var sourceWallet = await _walletService.GetAsync(walk.DogOwnerId, WalletType.Fees);
|
|
var targetWallet = await _walletService.GetAsync(walk.DogWalkerId, WalletType.Credits);
|
|
if (sourceWallet != null && targetWallet != null)
|
|
{
|
|
var sourceUser = await _appUserService.GetAsync(walk.DogOwnerId);
|
|
var targetUser = await _appUserService.GetAsync(walk.DogWalkerId);
|
|
|
|
if (sourceUser != null && targetUser != null)
|
|
{
|
|
var ammount = (long)(walk.Price * 100);
|
|
var transcationSuccess = await _mangoPayService.TransferMoneyAsync(walk.DogOwnerId, walk.DogWalkerId, walk.Id, ammount, fee, $"WalkId_Payment_{walk.Id}");
|
|
|
|
//Wallets aktualisieren
|
|
await _mangoPayService.GetWalletBalanceAsync(sourceUser.Id, WalletType.Credits);
|
|
await _mangoPayService.GetWalletBalanceAsync(sourceUser.Id, WalletType.Fees);
|
|
|
|
await _mangoPayService.GetWalletBalanceAsync(targetUser.Id, WalletType.Credits);
|
|
await _mangoPayService.GetWalletBalanceAsync(targetUser.Id, WalletType.Fees);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Zurücksetzen der App User in Bezug auf Mangopay
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<IActionResult> ResetAppUsers()
|
|
{
|
|
var appUsers = await _appUserService.GetAllAsync();
|
|
foreach (var appUser in appUsers)
|
|
{
|
|
appUser.PaymentId = string.Empty;
|
|
appUser.KycPassed = false;
|
|
appUser.KycPassedDate = null;
|
|
appUser.BankId = string.Empty;
|
|
appUser.Verified = false;
|
|
appUser.VerifiedDate = null;
|
|
appUser.AutoPayout = false;
|
|
appUser.PaymentTermsAccepted = false;
|
|
appUser.PaymentTermsAcceptedDate = null;
|
|
appUser.NationalityCode = string.Empty;
|
|
appUser.MainResidenceCode = string.Empty;
|
|
appUser.UpdatedAt = DateTime.UtcNow;
|
|
await _appUserService.CommitAsync("System");
|
|
}
|
|
|
|
var wallets = await _walletService.GetAllAsync();
|
|
foreach (var wallet in wallets)
|
|
{
|
|
_walletService.Remove(wallet);
|
|
}
|
|
await _walletService.CommitAsync("System");
|
|
|
|
return Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Für alle App-User prüfen ob diese, wenn nötig einen Mangopay-User und Wallets haben
|
|
/// </summary>
|
|
/// <returns>200 OK</returns>
|
|
public async Task<IActionResult> SetMangoPayAccounts()
|
|
{
|
|
var appUsers = await _appUserService.GetAllAsync();
|
|
|
|
foreach (var appUser in appUsers.Where(c => c.TermsAccepted && c.Address != null && !string.IsNullOrWhiteSpace(c.Address.CountryCode)))
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Prüfe Benutzer: {appUser.FirstName} {appUser.LastName}");
|
|
|
|
if (!string.IsNullOrWhiteSpace(appUser.PaymentId) || appUser.Type == AppUserType.DogWalker || appUser.Type == AppUserType.Both)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(appUser.PaymentId))
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName} hat keinen MangoPay User");
|
|
|
|
//Es gibt noch keinen MangopayUser für DogWalker oder BOTH!!!
|
|
if (string.IsNullOrWhiteSpace(appUser.NationalityCode))
|
|
appUser.NationalityCode = appUser.Address.CountryCode;
|
|
if(string.IsNullOrEmpty(appUser.MainResidenceCode))
|
|
appUser.MainResidenceCode = appUser.Address.CountryCode;
|
|
if (!appUser.PaymentTermsAccepted || appUser.PaymentTermsAcceptedDate == null)
|
|
{
|
|
appUser.PaymentTermsAccepted = true;
|
|
appUser.PaymentTermsAcceptedDate = DateTime.Now;
|
|
}
|
|
|
|
var createResult = await _mangoPayService.CreateOwnerAsync(appUser.Id, true);
|
|
if (createResult.Success)
|
|
{
|
|
appUser.PaymentId = createResult.Value;
|
|
appUser.UpdatedAt = DateTimeOffset.UtcNow;
|
|
await _appUserService.CommitAsync("System");
|
|
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName} hat nun die MangoPayId: {appUser.PaymentId}");
|
|
|
|
//Wallets anlegen
|
|
var walletFees = await _mangoPayService.CreateWalletAsync(appUser.Id, WalletType.Fees);
|
|
if(walletFees.Success)
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es wurde ein neues Fee-Wallet angelegt");
|
|
var walletCredits = await _mangoPayService.CreateWalletAsync(appUser.Id, WalletType.Credits);
|
|
if(walletCredits.Success)
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es wurde ein neues Credit-Wallet angelegt");
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName} es konnte kein MangoPay-User angelegt werden.");
|
|
if(!string.IsNullOrWhiteSpace(createResult.ErrorMessage))
|
|
System.Diagnostics.Debug.WriteLine(createResult.ErrorMessage);
|
|
if(createResult.ErrorMessages != null)
|
|
foreach (var error in createResult.ErrorMessages)
|
|
System.Diagnostics.Debug.WriteLine($"{error.Key} --> {error.Value}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName} hat einen MangoPay User mit der Id {appUser.PaymentId}");
|
|
|
|
//Es gibt einen MangoPay User. Das gilt nun für alle User.
|
|
var hasChanges = false;
|
|
if (string.IsNullOrWhiteSpace(appUser.NationalityCode))
|
|
{
|
|
appUser.NationalityCode = appUser.Address.CountryCode;
|
|
hasChanges = true;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(appUser.MainResidenceCode))
|
|
{
|
|
appUser.MainResidenceCode = appUser.Address.CountryCode;
|
|
hasChanges = true;
|
|
}
|
|
|
|
if (!appUser.PaymentTermsAccepted || appUser.PaymentTermsAcceptedDate == null)
|
|
{
|
|
appUser.PaymentTermsAccepted = true;
|
|
appUser.PaymentTermsAcceptedDate = DateTime.Now;
|
|
hasChanges = true;
|
|
}
|
|
|
|
if (hasChanges)
|
|
{
|
|
appUser.UpdatedAt = DateTimeOffset.UtcNow;
|
|
await _appUserService.CommitAsync("System");
|
|
}
|
|
|
|
//Hier nun Prüfen ob ein Benutzer bei Mangopay besteht.
|
|
var hasOwnerResult = await _mangoPayService.OwnerExistsAsync(appUser.PaymentId);
|
|
if (hasOwnerResult.Success)
|
|
{
|
|
if (hasOwnerResult.Value == false)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Die MangoPay-Id {appUser.PaymentId} existiert nicht bei MangoPay");
|
|
|
|
//Es gibt keinen User, also einen neuen anlegen und die neue Id speichern
|
|
var createResult = await _mangoPayService.CreateOwnerAsync(appUser.Id, true);
|
|
if (createResult.Success)
|
|
{
|
|
appUser.PaymentId = createResult.Value;
|
|
appUser.UpdatedAt = DateTimeOffset.UtcNow;
|
|
await _appUserService.CommitAsync("System");
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName} hat nun die MangoPayId: {appUser.PaymentId}");
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName} konnte keine MangoPay ID bekommen");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Die MangoPay-Id {appUser.PaymentId} ist gültig!!!!");
|
|
}
|
|
|
|
//Nun Wallets prüfen
|
|
var wallets = await _walletService.GetAllAsync(appUser.Id);
|
|
var creditWallet = wallets.FirstOrDefault(c => c.Type == WalletType.Credits);
|
|
if (creditWallet == null)
|
|
{
|
|
//Wallet anlegen
|
|
var walletCredits = await _mangoPayService.CreateWalletAsync(appUser.Id, WalletType.Credits);
|
|
if(walletCredits.Success)
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es wurde ein neues Credit-Wallet angelegt");
|
|
else
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es konnte kein neues Credit-Wallet angelegt werde");
|
|
}
|
|
else
|
|
{
|
|
//Prüfen ob Wallet existiert, sonst anlegen
|
|
var walletExitsResult = await _mangoPayService.WalletExistsAsync(creditWallet.WalletId);
|
|
if (walletExitsResult.Success && !walletExitsResult.Value)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Das Wallet mit der Id {creditWallet.WalletId} existiert nicht. Neues anlegen!");
|
|
var walletCredits = await _mangoPayService.CreateWalletAsync(appUser.Id, WalletType.Credits);
|
|
if (walletCredits.Success)
|
|
{
|
|
_walletService.Remove(creditWallet);
|
|
await _walletService.CommitAsync("System");
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es wurde ein neues Credit-Wallet angelegt");
|
|
}
|
|
else
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es konnte kein neues Credit-Wallet angelegt werde");
|
|
}
|
|
}
|
|
var feeWallet = wallets.FirstOrDefault(c => c.Type == WalletType.Fees);
|
|
if (feeWallet == null)
|
|
{
|
|
//Wallet anlegen
|
|
var walletFees = await _mangoPayService.CreateWalletAsync(appUser.Id, WalletType.Fees);
|
|
if (walletFees.Success)
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es wurde ein neues Fee-Wallet angelegt");
|
|
else
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es konnte kein neues Fee-Wallet angelegt werde");
|
|
}
|
|
else
|
|
{
|
|
//Prüfen ob Wallet existiert, sonst anlegen
|
|
var walletExitsResult = await _mangoPayService.WalletExistsAsync(feeWallet.WalletId);
|
|
if (walletExitsResult.Success && !walletExitsResult.Value)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Das Wallet mit der Id {feeWallet.WalletId} existiert nicht. Neues anlegen!");
|
|
var walletFees = await _mangoPayService.CreateWalletAsync(appUser.Id, WalletType.Fees);
|
|
if (walletFees.Success)
|
|
{
|
|
_walletService.Remove(feeWallet);
|
|
await _walletService.CommitAsync("System");
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es wurde ein neues Fees-Wallet angelegt");
|
|
}
|
|
else
|
|
System.Diagnostics.Debug.WriteLine($"{appUser.FirstName} {appUser.LastName}: Es konnte kein neues Fees-Wallet angelegt werde");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Benutzer: {appUser.FirstName} {appUser.LastName} hat keine PaymentId und folgenden Typ: {appUser.Type}");
|
|
}
|
|
}
|
|
|
|
return Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Echtes Löschen von AppUsers die als gelöscht markiert sind
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<IActionResult> RemoveDeletedAppUsers()
|
|
{
|
|
dynamic model = new ExpandoObject();
|
|
|
|
var ratingTargetsToUpdate = new List<Tuple<string, RatingTarget>>();
|
|
|
|
var appUsers = await _appUserService.GetDeletedAsync();
|
|
model.AppUsersCount = appUsers.Count();
|
|
model.UsersCount = 0;
|
|
model.FavouritesCount = 0;
|
|
model.SystemMessageCount = 0;
|
|
model.DeviceCount = 0;
|
|
model.DeviceDeinstallationCount = 0;
|
|
model.ConversationsCount = 0;
|
|
model.RatingsCount = 0;
|
|
|
|
|
|
foreach (var appUser in appUsers)
|
|
{
|
|
//Schritt 1: löschen der Dateien
|
|
var postingPath = FileServiceHelper.GetAppUserPath(appUser.Id);
|
|
await FileService.ClearDirectoryAsync(FileServiceHelper.DocumentContainer, postingPath);
|
|
await RemoveThumbnail(FileServiceHelper.DocumentContainer, appUser.Photo, 400);
|
|
await RemoveThumbnail(FileServiceHelper.DocumentContainer, appUser.Photo, 200);
|
|
await RemoveThumbnail(FileServiceHelper.DocumentContainer, appUser.Photo, 100);
|
|
|
|
//Schritt 2: Benutzer und Refreshtokens löschen
|
|
var applicationUser = await _userService.GetByAppUserAsync(appUser.Id);
|
|
if (applicationUser != null)
|
|
{
|
|
//Refreshtokens löschen
|
|
await _refreshTokenService.RemoveAllAsync(applicationUser.Id, applicationUser.UserName);
|
|
//Benutzer löschen
|
|
_userService.Remove(applicationUser);
|
|
model.UsersCount += 1;
|
|
}
|
|
|
|
//Schritt 3: Walker-Profil löschen
|
|
await _appUserService.RemoveWalkerProfileAsync(appUser.Id);
|
|
|
|
//Schritt 4: Blockierungen löschen
|
|
await _appUserService.RemoveBlocksByBlockedUserAsync(appUser.Id);
|
|
|
|
//Schritt 5: Ratings löschen
|
|
var ratingTargets = await _ratingService.DeleteAllForAppUserAsync(appUser.Id);
|
|
foreach (var ratingTarget in ratingTargets)
|
|
{
|
|
if (ratingTargetsToUpdate.FirstOrDefault(c => c.Item1 == ratingTarget.Item1 && c.Item2 == ratingTarget.Item2) == null)
|
|
ratingTargetsToUpdate.Add(ratingTarget);
|
|
}
|
|
|
|
//Schritt 6: Favourites löschen
|
|
var favouritesCount = await _favouriteService.DeleteAllForAppUserAsync(appUser.Id);
|
|
model.FavouritesCount += favouritesCount;
|
|
|
|
//Schritt 7: SystemMessages löschen
|
|
var systemMessageCount = await _systemMessageService.DeleteAllForAppUserAsync(appUser.Id);
|
|
model.SystemMessageCount += systemMessageCount;
|
|
|
|
//Schritt 8: Devices vor löschen abmelden
|
|
var devices = await _deviceService.GetAllAsync(appUser.Id);
|
|
foreach (var device in devices)
|
|
{
|
|
model.DeviceCount += 1;
|
|
#if RELEASE
|
|
var success = await _pushNotificationService.DeleteInstallationByIdAsync(device.InstallationId);
|
|
if(success)
|
|
model.DeviceDeinstallationCount += 1;
|
|
#endif
|
|
await _deviceService.DeleteAsync(appUser.Id, device.InstallationId, true);
|
|
}
|
|
|
|
//Schritt 9: Konversationen löschen
|
|
var conversations = await _messageService.RemoveConversationByAppUserAsync(appUser.Id);
|
|
model.ConversationsCount += conversations;
|
|
|
|
//AppReports löschen
|
|
var appUserReportCount = await _appUserReportService.DeleteAllForAppUserAsync(appUser.Id);
|
|
System.Diagnostics.Debug.WriteLine($"AppUserReports: {appUserReportCount}");
|
|
|
|
_appUserService.Remove(appUser);
|
|
|
|
}
|
|
|
|
model.RatingsCount = ratingTargetsToUpdate.Count;
|
|
|
|
//Schritt 10: Löschen der gesamten Daten
|
|
await _appUserService.CommitAsync(User.Identity.Name);
|
|
|
|
//Schritt 11: Rating-Statistiken aktualisieren
|
|
if (ratingTargetsToUpdate.Any())
|
|
{
|
|
foreach (var ratingTargetToUpdate in ratingTargetsToUpdate)
|
|
{
|
|
await _ratingService.UpdateRatingStatisticsAsync(ratingTargetToUpdate.Item1, ratingTargetToUpdate.Item2);
|
|
}
|
|
await _ratingService.CommitAsync(User.Identity.Name);
|
|
}
|
|
|
|
return View(model);
|
|
}
|
|
}
|
|
}
|