399 lines
19 KiB
C#
399 lines
19 KiB
C#
using AutoMapper;
|
|
using gehGassi.Common.Data;
|
|
using gehGassi.Core.Interfaces;
|
|
using gehGassi.Core.Services;
|
|
using gehGassi.Domain.Common;
|
|
using gehGassi.Permissions;
|
|
using gehGassi.Web.Auth;
|
|
using gehGassi.Web.Auth.Attributes;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Localization;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using gehGassi.Web.Helper;
|
|
using gehGassi.Web.Models;
|
|
using System.Threading.Tasks;
|
|
using gehGassi.Domain.Dogs;
|
|
using gehGassi.Dto.Messages;
|
|
using System;
|
|
using gehGassi.Web.Hubs;
|
|
using gehGassi.External.Services;
|
|
|
|
namespace gehGassi.Web.Controllers
|
|
{
|
|
/// <summary>
|
|
/// Controller für die Verwaltung von Reklamationen
|
|
/// </summary>
|
|
[Authorize]
|
|
public class WalkComplaintController : BaseController
|
|
{
|
|
private readonly IMapper _mapper;
|
|
private readonly IStringLocalizer<WalkComplaintController> _localizer;
|
|
private readonly IWalkComplaintService _walkComplaintService;
|
|
private readonly IWalkService _walkService;
|
|
private readonly IAppUserService _appUserService;
|
|
private readonly IDogService _dogService;
|
|
private readonly ISystemMessageService _systemMessageService;
|
|
private readonly IAppHubSender _appHubSender;
|
|
private readonly ITransactionFeeService _transactionFeeService;
|
|
private readonly IWalletService _walletService;
|
|
private readonly IMangoPayService _mangoPayService;
|
|
private readonly IPushNotificationService _pushNotificationService;
|
|
|
|
/// <summary>
|
|
/// Erstellt eine Instanz
|
|
/// </summary>
|
|
/// <param name="mapper">Instanz eines IMapper</param>
|
|
/// <param name="localizer">Instanz eines IStringLocalizer</param>
|
|
/// <param name="walkComplaintService">Instanz eines IWalkComplaintService</param>
|
|
/// <param name="walkService">Instanz eines IWalkService</param>
|
|
/// <param name="appUserService">Instanz eines IAppUserService</param>
|
|
/// <param name="dogService">Instanz eines IDogService</param>
|
|
/// <param name="systemMessageService">Instanz eines ISystemMessageService</param>
|
|
/// <param name="appHubSender">Instanz eines IAppHubSender</param>
|
|
/// <param name="transactionFeeService">Instanz eines ITransactionFeeService</param>
|
|
/// <param name="walletService">Instanz eines IWalletService</param>
|
|
/// <param name="mangoPayService">Instanz eines IMangoPayService</param>
|
|
/// <param name="pushNotificationService">Instanz eines IPushNotificationService</param>
|
|
public WalkComplaintController(IMapper mapper, IStringLocalizer<WalkComplaintController> localizer, IWalkComplaintService walkComplaintService, IWalkService walkService, IAppUserService appUserService, IDogService dogService,
|
|
ISystemMessageService systemMessageService, IAppHubSender appHubSender, ITransactionFeeService transactionFeeService, IWalletService walletService, IMangoPayService mangoPayService, IPushNotificationService pushNotificationService)
|
|
{
|
|
_mapper = mapper;
|
|
_localizer = localizer;
|
|
_walkComplaintService = walkComplaintService;
|
|
_walkService = walkService;
|
|
_appUserService = appUserService;
|
|
_dogService = dogService;
|
|
_systemMessageService = systemMessageService;
|
|
_appHubSender = appHubSender;
|
|
_transactionFeeService = transactionFeeService;
|
|
_walletService = walletService;
|
|
_mangoPayService = mangoPayService;
|
|
_pushNotificationService = pushNotificationService;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt einen View für die Verwaltung von Reklamationen zurück
|
|
/// </summary>
|
|
/// <returns>View</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.SettingsManage, Permission.SettingsComplaints)]
|
|
public IActionResult Index()
|
|
{
|
|
return View();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gibt eine Liste von Entitäten basierend auf Abfragekriterien zurück
|
|
/// </summary>
|
|
/// <param name="dm">Abfragekriterien</param>
|
|
/// <returns>Liste von gefundenen Entitäten</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.SettingsManage, Permission.SettingsComplaints)]
|
|
[HttpPost]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public IActionResult GetComplaints([FromBody] DataManager dm)
|
|
{
|
|
if (dm != null)
|
|
{
|
|
var propList = new List<ComplexProperty>();
|
|
dm.SetComplexProperties(propList);
|
|
|
|
if (dm.Where != null)
|
|
{
|
|
foreach (var whereFilter in dm.Where)
|
|
{
|
|
if (whereFilter.predicates == null)
|
|
continue;
|
|
foreach (var whereFilterPredicate in whereFilter.predicates)
|
|
{
|
|
if (whereFilterPredicate.Field == "walkType")
|
|
whereFilterPredicate.value = (WalkType)((int)((long)whereFilterPredicate.value));
|
|
if (whereFilterPredicate.Field == "walkServiceType")
|
|
whereFilterPredicate.value = (WalkServiceType)((int)((long)whereFilterPredicate.value));
|
|
if (whereFilterPredicate.Field == "source")
|
|
whereFilterPredicate.value = (WalkComplaintSource)((int)((long)whereFilterPredicate.value));
|
|
if (whereFilterPredicate.Field == "type")
|
|
whereFilterPredicate.value = (WalkComplaintType)((int)((long)whereFilterPredicate.value));
|
|
if (whereFilterPredicate.Field == "status")
|
|
whereFilterPredicate.value = (WalkComplaintStatus)((int)((long)whereFilterPredicate.value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var resultList = _walkComplaintService.FilterWithNames(dm?.SearchValue ?? "", false);
|
|
|
|
//Sortierung
|
|
resultList = dm.ApplySorting(resultList);
|
|
//Filter
|
|
resultList = dm.ApplyFiltering(resultList, out var countFiltered);
|
|
//Paging
|
|
resultList = dm.ApplyPaging(resultList);
|
|
|
|
var resultListVm = resultList.ToList().Select(item => _mapper.Map<WalkComplaintListVm>(item)).ToList();
|
|
|
|
foreach (var itemVm in resultListVm)
|
|
{
|
|
itemVm.WalkTypeText = itemVm.WalkType.GetDisplayName(AnnotationsLocalizer);
|
|
itemVm.WalkServiceTypeText = itemVm.WalkServiceType.GetDisplayName(AnnotationsLocalizer);
|
|
itemVm.SourceText = itemVm.Source.GetDisplayName(AnnotationsLocalizer);
|
|
itemVm.TypeText = itemVm.Type.GetDisplayName(AnnotationsLocalizer);
|
|
itemVm.StatusText = itemVm.Status.GetDisplayName(AnnotationsLocalizer);
|
|
}
|
|
|
|
//FilterPreview?
|
|
if (!dm.RequiresCounts)
|
|
return Json(resultListVm);
|
|
|
|
return Json(new { result = resultListVm, count = countFiltered });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Details einer Reklamation
|
|
/// </summary>
|
|
/// <param name="id">Id der reklamation</param>
|
|
/// <returns>PartialView</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.SettingsManage, Permission.SettingsComplaints)]
|
|
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
|
|
public async Task<IActionResult> Details(string id)
|
|
{
|
|
var item = await _walkComplaintService.GetAsync(id);
|
|
if (item != null)
|
|
{
|
|
var model = _mapper.Map<WalkComplaintVm>(item);
|
|
|
|
//Nun noch weitere Details holen....
|
|
var walk = await _walkService.GetWalkWithNamesAsync(item.WalkId);
|
|
walk.Dogs = new List<DogMinInfo>();
|
|
if (!string.IsNullOrWhiteSpace(walk.DogsJson))
|
|
{
|
|
var dogsList = JsonSerializer.Deserialize<List<DogWalkJson>>(walk.DogsJson, new JsonSerializerOptions(JsonSerializerDefaults.Web));
|
|
foreach (var dogItem in dogsList)
|
|
{
|
|
var dog = await _dogService.GetWithNamesAsync(dogItem.Id, "DE", LocalizationOptions.Value.DefaultCulture, true);
|
|
if (dog != null)
|
|
{
|
|
walk.Dogs.Add(new DogMinInfo()
|
|
{
|
|
Id = dog.Id,
|
|
Index = dog.Index,
|
|
Version = dog.Version,
|
|
UpdatedAt = dog.UpdatedAt,
|
|
Deleted = dog.Deleted,
|
|
DogRaceId = dog.DogRaceId,
|
|
DogRaceName = dog.DogRaceName,
|
|
Name = dog.Name,
|
|
Sex = dog.Sex,
|
|
Size = dog.Size,
|
|
BirthDate = dog.BirthDate
|
|
});
|
|
}
|
|
}
|
|
}
|
|
ViewBag.Walk = walk;
|
|
|
|
|
|
var dogOwner = await _appUserService.GetAsync(walk.DogOwnerId);
|
|
ViewBag.DogOwner = dogOwner;
|
|
|
|
var dogWalker = await _appUserService.GetAsync(walk.DogWalkerId);
|
|
ViewBag.DogWalker = dogWalker;
|
|
|
|
return PartialView("_Details", model);
|
|
}
|
|
return PartialView("_Error");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Details einer Reklamation
|
|
/// </summary>
|
|
/// <param name="model">Model</param>
|
|
/// <returns>Json</returns>
|
|
[Authorize(Policy = Policies.PowerUserOnly)]
|
|
[HasPermission(Permission.SettingsManage, Permission.SettingsComplaints)]
|
|
[ValidateAntiForgeryToken]
|
|
[HttpPost]
|
|
public async Task<IActionResult> Details(WalkComplaintVm model)
|
|
{
|
|
var result = new ResponseVm { Success = false };
|
|
|
|
if (ModelState.IsValid)
|
|
{
|
|
var item = await _walkComplaintService.GetAsync(model.Id);
|
|
if (item.Status < model.Status)
|
|
{
|
|
if (item.Status <= WalkComplaintStatus.InProgress)
|
|
{
|
|
item.Status = (WalkComplaintStatus)model.Status;
|
|
item.Comment = model.Comment;
|
|
item.UserName = User.Identity.Name;
|
|
await _walkComplaintService.CommitAsync(User.Identity.Name);
|
|
|
|
var walkUsed = await _walkService.GetAsync(model.WalkId);
|
|
|
|
//Nun den Status behandeln
|
|
if (item.Status > WalkComplaintStatus.InProgress)
|
|
{
|
|
item.Resolved = DateTimeOffset.UtcNow;
|
|
await _walkComplaintService.CommitAsync(User.Identity.Name);
|
|
walkUsed.Status = WalkStatus.ComplainResolved;
|
|
}
|
|
|
|
if (item.Status == WalkComplaintStatus.Resolved_Pay)
|
|
{
|
|
walkUsed.PaymentStatus = PaymentStatus.Paid;
|
|
await _walkService.CommitAsync(User.Identity.Name);
|
|
|
|
//Zahlung veranlassen....
|
|
decimal feeDecimal = 0;
|
|
long fee = 0;
|
|
var gehGassiFee = await _transactionFeeService.GetMinGehGassiFeeAsync(walkUsed.Price);
|
|
if (gehGassiFee != null)
|
|
{
|
|
if (gehGassiFee.Percent > 0)
|
|
{
|
|
var percent = walkUsed.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(walkUsed.DogOwnerId, WalletType.Fees);
|
|
var targetWallet = await _walletService.GetAsync(walkUsed.DogWalkerId, WalletType.Credits);
|
|
if (sourceWallet != null && targetWallet != null)
|
|
{
|
|
var sourceUser = await _appUserService.GetAsync(walkUsed.DogOwnerId);
|
|
var targetUser = await _appUserService.GetAsync(walkUsed.DogWalkerId);
|
|
|
|
if (sourceUser != null && targetUser != null)
|
|
{
|
|
var ammount = (long)(walkUsed.Price * 100);
|
|
var transcationSuccess = await _mangoPayService.TransferMoneyAsync(walkUsed.DogOwnerId, walkUsed.DogWalkerId, walkUsed.Id, ammount, fee, $"WalkId_Payment_{walkUsed.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);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (item.Status == WalkComplaintStatus.Resolved_Refund)
|
|
{
|
|
// Zurücküberweisen der Summe vom Transaktionskonto auf das Guthabenkonto
|
|
if (walkUsed.Price > 0)
|
|
{
|
|
var ammount = (long)(walkUsed.Price * 100);
|
|
var tag = $"Walk_Complaint_Refund_{walkUsed.Id}";
|
|
var refundResult = await _mangoPayService.TransferMoneyFromFeeToCreditAccountAsync(walkUsed.DogOwnerId, ammount, tag);
|
|
if (refundResult.Success)
|
|
walkUsed.PaymentStatus = PaymentStatus.Refunded;
|
|
else
|
|
walkUsed.PaymentStatus = PaymentStatus.Voided;
|
|
}
|
|
else
|
|
walkUsed.PaymentStatus = PaymentStatus.Voided;
|
|
|
|
await _walkService.CommitAsync(User.Identity.Name);
|
|
}
|
|
|
|
if (item.Status == WalkComplaintStatus.Resolved_Gehgassi)
|
|
{
|
|
// Zurücküberweisen der Summe vom Transaktionskonto auf das Guthabenkonto
|
|
if (walkUsed.Price > 0)
|
|
{
|
|
var ammount = (long)(walkUsed.Price * 100);
|
|
var tag = $"Walk_Complaint_RefundPay_{walkUsed.Id}";
|
|
var refundResult = await _mangoPayService.TransferMoneyFromFeeToCreditAccountAsync(walkUsed.DogOwnerId, ammount, tag);
|
|
if (refundResult.Success)
|
|
walkUsed.PaymentStatus = PaymentStatus.RefundendAndPayed;
|
|
else
|
|
walkUsed.PaymentStatus = PaymentStatus.Voided;
|
|
}
|
|
else
|
|
walkUsed.PaymentStatus = PaymentStatus.Voided;
|
|
|
|
await _walkService.CommitAsync(User.Identity.Name);
|
|
}
|
|
|
|
_systemMessageService.Add(walkUsed.DogWalkerId, AppUserType.DogWalker, walkUsed.Id, SystemMessageTables.Walk, SystemMessageType.WalkComplainedUpdate, DateTimeOffset.UtcNow.AddDays(14));
|
|
await _systemMessageService.CommitAsync(User.Identity.Name);
|
|
await _appHubSender.SystemMessageAddedAsync(walkUsed.DogWalkerId);
|
|
await _pushNotificationService.SendWalkComplainedUpdateAsync(walkUsed.DogWalkerId, walkUsed.Id, AppMode.DogWalker);
|
|
|
|
_systemMessageService.Add(walkUsed.DogOwnerId, AppUserType.DogOwner, walkUsed.Id, SystemMessageTables.Walk, SystemMessageType.WalkComplainedUpdate, DateTimeOffset.UtcNow.AddDays(14));
|
|
await _systemMessageService.CommitAsync(User.Identity.Name);
|
|
await _appHubSender.SystemMessageAddedAsync(walkUsed.DogOwnerId);
|
|
await _pushNotificationService.SendWalkComplainedUpdateAsync(walkUsed.DogOwnerId, walkUsed.Id, AppMode.DogOwner);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
item.Comment = model.Comment;
|
|
item.UserName = User.Identity.Name;
|
|
await _walkComplaintService.CommitAsync(User.Identity.Name);
|
|
}
|
|
|
|
result.Data = item.ToCamelCaseJson();
|
|
result.Success = true;
|
|
result.Html = string.Empty;
|
|
return Json(new { result.Success, result.Html, result.Data });
|
|
}
|
|
|
|
//Nun noch weitere Details holen....
|
|
var walk = await _walkService.GetWalkWithNamesAsync(model.WalkId);
|
|
walk.Dogs = new List<DogMinInfo>();
|
|
if (!string.IsNullOrWhiteSpace(walk.DogsJson))
|
|
{
|
|
var dogsList = JsonSerializer.Deserialize<List<DogWalkJson>>(walk.DogsJson, new JsonSerializerOptions(JsonSerializerDefaults.Web));
|
|
foreach (var dogItem in dogsList)
|
|
{
|
|
var dog = await _dogService.GetWithNamesAsync(dogItem.Id, "DE", LocalizationOptions.Value.DefaultCulture, true);
|
|
if (dog != null)
|
|
{
|
|
walk.Dogs.Add(new DogMinInfo()
|
|
{
|
|
Id = dog.Id,
|
|
Index = dog.Index,
|
|
Version = dog.Version,
|
|
UpdatedAt = dog.UpdatedAt,
|
|
Deleted = dog.Deleted,
|
|
DogRaceId = dog.DogRaceId,
|
|
DogRaceName = dog.DogRaceName,
|
|
Name = dog.Name,
|
|
Sex = dog.Sex,
|
|
Size = dog.Size,
|
|
BirthDate = dog.BirthDate
|
|
});
|
|
}
|
|
}
|
|
}
|
|
ViewBag.Walk = walk;
|
|
|
|
|
|
var dogOwner = await _appUserService.GetAsync(walk.DogOwnerId);
|
|
ViewBag.DogOwner = dogOwner;
|
|
|
|
var dogWalker = await _appUserService.GetAsync(walk.DogWalkerId);
|
|
ViewBag.DogWalker = dogWalker;
|
|
|
|
result.Html = await PartialView("_Details", model).ToStringAsync(ControllerContext);
|
|
return Json(result);
|
|
}
|
|
}
|
|
}
|