Notes

using Application.Common.Services;
using Application.MappingProfiles;
using Application.Models;
using Application.Models.Payments;
using Application.Ports.Persistences;
using Application.Services.Localization;
using Application.Services.Main;
using Application.Services.ThirdParty;
using AutoMapper;
using Core.Entities.Concrete;
using Core.Enums;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using Shared.Exceptions;
using Shared.Helpers;
using System.Text;
using System.Transactions;

namespace Application.Services.Payments;

public class PaymentManager : BaseManager, IPaymentService
{
#region Dependencies
private readonly IPaymentRepository _paymentRepository;
private readonly IRequestRepository _requestRepository;
private readonly IUserRepository _userRepository;
private readonly IUserService _userService;
private readonly INotificationRepository _notificationRepository;
private readonly IUserPolicyRepository _userPolicyRepository;


private readonly IUserRequestStepRepository _userRequestStepRepository;
private readonly IPaymentGroupRepository _paymentGroupRepository;
private readonly IRequestService _requestService;
private readonly IConfiguration _configuration;
private readonly IDateTime _dateTime;
private readonly IRequestStepRepository _requestStepRepository;
private readonly INotificationService _notificationService;
private readonly ISmsService _smsService;

public PaymentManager(IHttpContextAccessor httpContextAccessor,
IMapper mapper, LocalizationService translation,
IPaymentRepository paymentRepository,
IRequestRepository requestRepository,
IDateTime dateTime,
IUserPolicyRepository userPolicyRepository,
IConfiguration configuration,
INotificationRepository notificationRepository,
IUserRepository userRepository,
IUserRequestStepRepository userRequestStepRepository,
IUserService userService, IPaymentGroupRepository paymentGroupRepository, IRequestService requestService, IRequestStepRepository requestStepRepository, INotificationService notificationService, ISmsService smsService) :
base(httpContextAccessor, mapper, translation)
{
_paymentRepository = paymentRepository;
_requestRepository = requestRepository;
_dateTime = dateTime;
_userPolicyRepository = userPolicyRepository;
_configuration = configuration;
_notificationRepository = notificationRepository;
_userRepository = userRepository;
_userRequestStepRepository = userRequestStepRepository;
_userService = userService;
_paymentGroupRepository = paymentGroupRepository;
_requestService = requestService;
_requestStepRepository = requestStepRepository;
_notificationService = notificationService;
_smsService = smsService;
}
#endregion
public async Task<PaymentGroupGetAllResponse> GetPaymentGroupsAsync(int requestId, PaginationFilter paginationFilter)
{
PaymentGroupGetAllResponse response = new();
var query = _paymentGroupRepository.GetQuery().Include(x => x.Payments)
.Include(x => x.User)
.ThenInclude(x => x.UserPolicies)
.ThenInclude(x => x.Policy)
.Where(x => x.RequestId == requestId);
var policy = await GetUserPolicy();
if (policy == null) throw new NotFoundException("Səlahiyyət tapılmadı");
PaginatedMappedList<PaymentGroupDto, Core.Entities.Concrete.PaymentGroup> data;
switch (policy.Policy.Name)
{
case nameof(Policies.AAYDAOperator):
case nameof(Policies.AAYDAGuidance):
data = await query.Where(x => x.Name == "AAYDA").PaginatedMappedListAsync<PaymentGroupDto, PaymentGroup>(Mapper, paginationFilter.PageNumber,
paginationFilter.PageSize);
break;
case nameof(Policies.DINBDYPIOperator):
case nameof(Policies.DINBDYPIGuidance):
data = await query.Where(x => x.Name == "DIN BDYPI").PaginatedMappedListAsync<PaymentGroupDto, PaymentGroup>(Mapper, paginationFilter.PageNumber,
paginationFilter.PageSize);
break;
default:
data = await query.PaginatedMappedListAsync<PaymentGroupDto, PaymentGroup>(Mapper, paginationFilter.PageNumber,
paginationFilter.PageSize);
break;
}

response.PaymentGroupDtos = data;
return response;
}
public async Task CallbackPayment(PaymentCallbackRequest paymentCallbackRequest)
{
string? authToken = Accessor.AppConfiguration["AynaPay:AuthKey"];
if (paymentCallbackRequest.SystemAuthenticationToken != authToken)


throw new BadRequestException("Sorğudakı token düzgün deyil");
var query = _paymentGroupRepository.GetQuery();
var payment = await query.Include(x => x.Payments).FirstOrDefaultAsync(x => x.PaymentId == paymentCallbackRequest.PaymentId && x.RequestId == paymentCallbackRequest.SystemRecordId);
if (payment == null) throw new NotFoundException("Ödəniş tapılmadı");
await PayAmount(payment);
}
public async Task CallBackSuccessPayment(PaymentCallBackSuccessRequest paymentCallbackRequest)
{
var query = _paymentGroupRepository.GetQuery();
var payment = await query.Include(x => x.Payments).FirstOrDefaultAsync(x => x.PaymentId == paymentCallbackRequest.PaymentId && x.RequestId == paymentCallbackRequest.SystemRecordId);
if (payment == null) throw new NotFoundException("Ödəniş tapılmadı");
await PayAmount(payment);
}
public async Task<bool> ChangePaymentStatus(int paymentId, PaymentStatus status)
{
var payment = await _paymentGroupRepository.GetFirstAsyncWithInclude(x => x.Id == paymentId, "Payments");
if (payment == null) throw new NotFoundException("Ödəniş tapılmadı");


var existsRequest = await _requestService.GetRequestByIdWithNoTracking(payment.RequestId);
if (existsRequest == null) throw new NotFoundException("Müraciət tapılmadı");
var userId = payment.UserId;
var userPolicy = await GetUserPolicy();
if (userId == userPolicy.UserId)
{
if (payment.PaymentStatus != PaymentStatus.Paid)
{
if (status == PaymentStatus.Paid)
{
string name = payment.Name.ToUpper();
if (name != "AYNA" && name != "AAYDA" && name != "DIN BDYPI") throw new NotFoundException($"Ad tapılmadı");
payment.PaymentStatus = PaymentStatus.Paid;
PaidSubPayments(payment);
await _paymentGroupRepository.UpdateAsync(payment);
await ChangeStatusesWhenPaid(existsRequest, name);
}
else
{
payment.PaymentStatus = status;
await _paymentGroupRepository.UpdateAsync(payment);
}
return true;
}
else
{
throw new BadRequestException("Siz artıq ödəniş etmisiniz");
}
}
else
{
throw new BadRequestException("Bu əməliyyat üçün icazəniz yoxdur");
}
}

private async Task PayAmount(PaymentGroup payment)
{
var existsRequest = await _requestService.GetRequestByIdWithNoTracking(payment.RequestId);
if (existsRequest == null) throw new NotFoundException("Müraciət tapılmadı");
string name = payment.Name.ToUpper();
if (name != "AYNA" && name != "AAYDA" && name != "DIN BDYPI") throw new NotFoundException($"Ad tapılmadı");
var request = await CheckPaymentStatusAsync(payment.PaymentId);


if (request.Status == PaymentStatus.Paid.ToString())
{
payment.PaymentStatus = PaymentStatus.Paid;
PaidSubPayments(payment);
await ChangeStatusesWhenPaid(existsRequest, name);
}
await _paymentGroupRepository.UpdateAsync(payment);
}

private static void PaidSubPayments(PaymentGroup payment)
{
if (payment.Payments != null)
{
foreach (var p in payment.Payments)
{
p.PaymentStatus = PaymentStatus.Paid;
}
}
}

public async Task<CallBackPaymentResponse> CheckPaymentStatusAsync(string paymentId)
{
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(_configuration["AynaPay:Url"]);
httpClient.DefaultRequestHeaders.Add("AuthenticationToken", _configuration["AynaPay:AuthKey"]);


CallBackPaymentResponse data = new CallBackPaymentResponse();
data.Status = PaymentStatus.Pending.ToString();

var startTime = DateTime.UtcNow;
var timeout = TimeSpan.FromSeconds(30);

while (data.Status != PaymentStatus.Paid.ToString())
{
if (DateTime.UtcNow - startTime > timeout)
{
throw new TimeoutException("Payment status check timed out after 1 minute.");
}

var response = await httpClient.PostAsync($"/api/payment/CheckPaymentStatus?paymentId={paymentId}", null);
string responseContent = await response.Content.ReadAsStringAsync();
data = JsonConvert.DeserializeObject<CallBackPaymentResponse>(responseContent);

await Task.Delay(500);
}

return data;
}

public async Task<PaymentGetDto?> GeneratePaymentDto(PaymentRequest paymentRequest)
{
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(_configuration["AynaPay:Url"]);
httpClient.DefaultRequestHeaders.Add("AuthenticationToken", _configuration["AynaPay:AuthKey"]);


string json = JsonConvert.SerializeObject(paymentRequest);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await httpClient.PostAsync("/api/payment/CreatePayment", content);
string responseContent = await response.Content.ReadAsStringAsync();

var data = JsonConvert.DeserializeObject<PaymentGetDto>(responseContent);
return data;
}

public async Task<PaymentResponse> DeletePaymentByIdAsync(int paymentId)
{
bool checkDelete = false;
var entity = await _paymentRepository.GetQuery().FirstOrDefaultAsync(x => x.Id == paymentId);
if (entity == null) throw new BadRequestException("Ödəniş tapılmadı");
if (entity.Description == "Dövlət rüsumu") throw new BadRequestException("Dövlət rüsumunu silmək mümkün deyil");
var amount = entity.Amount;
PaymentGroup paymentGroup = await _paymentGroupRepository.GetFirstAsyncWithInclude(x => x.Id == entity.PaymentGroupId, "Payments");
if (paymentGroup == null) throw new BadRequestException("Ödəniş tapılmadı");
if (paymentGroup.Payments?.Count() == 1) checkDelete = true;
await _paymentRepository.HardDeleteAsync(entity);
if (checkDelete) await _paymentGroupRepository.HardDeleteAsync(paymentGroup);
else
{
paymentGroup.TotalAmount -= amount;
bool checkUnPaid = paymentGroup.Payments.Any(x => x.PaymentStatus != PaymentStatus.Paid);
if (!checkUnPaid)
{
paymentGroup.PaymentStatus = PaymentStatus.Paid;
}
await _paymentGroupRepository.UpdateAsync(paymentGroup);
}
return new PaymentResponse { Id = paymentId };
}
public async Task<PaymentResponse> CreatePaymentGeneral(int requestId, SaveBulkPaymentsRequest bulkrequest, string name)
{
using TransactionScope scope = new(TransactionScopeAsyncFlowOption.Enabled);
try
{
var existRequest = await _requestRepository
.GetFirstAsyncWithIncludeList(x => x.Id == requestId, isTrack: false, new string[]
{
"User",
"PaymentGroups.Payments",
"User.UserPolicies",
"RequestSteps",
"User.UserPolicies.Policy",
});

if (existRequest == null) throw new NotFoundException("Müraciət tapılmadı");
var policy = await GetUserPolicy();

if (name == "DIN BDYPI" && bulkrequest.BulkPayments.Any(x => x.AccompanyingForm == null)) throw new BadRequestException("Müşayiət forması seçilməmişdir");
if (name == "DIN BDYPI" && (bulkrequest.BulkPayments.Any(x => x.AccompanyingForm == AccompanyingForm.Unaccompanied) || bulkrequest.BulkPayments.Any(x => x.AccompanyingForm == AccompanyingForm.None)))
throw new BadRequestException("Müşaiət forması seçmədiyiniz üçün ödəniş yarada bilməzsiz.");
StepType step;
PaymentGroup aaydaPayment = null;
PaymentGroup dypPayment = null;
PaymentGroup aaydaPaymentRusum = null;
PaymentGroup unpaidPaymentAAYDA = await _paymentGroupRepository.GetFirstAsync(x => x.RequestId == requestId && x.PaymentStatus != PaymentStatus.Paid && x.Name.ToUpper() == "AAYDA");
PaymentGroup unpaidPaymentDYP = await _paymentGroupRepository.GetFirstAsync(x => x.RequestId == requestId && x.PaymentStatus != PaymentStatus.Paid && x.Name.ToUpper() == "DIN BDYPI");
switch (policy.Policy.Name)
{
case nameof(Policies.AAYDAOperator):
step = StepType.aayda_operator;
var payment = existRequest.PaymentGroups.FirstOrDefault();
if (payment != null)
{
aaydaPaymentRusum = existRequest.PaymentGroups.FirstOrDefault(x => x.Name == "AAYDA" && x.Payments.Any(d => d.Description.Contains("Dövlət rüsumu")));
aaydaPayment = existRequest.PaymentGroups.FirstOrDefault(x => x.Name == "AAYDA");
dypPayment = existRequest.PaymentGroups.FirstOrDefault(x => x.Name == "DIN BDYPI");
}
if (unpaidPaymentDYP != null)
{
AddNewPaymentStatus(existRequest, AynaStatus.Payment_Pending_AAYDA_DYP, CarrierStatus.Payment_Pending_AAYDA_DYP);
}
else
{
AddNewPaymentStatus(existRequest, AynaStatus.Payment_Pending_AAYDA, CarrierStatus.Payment_Pending_AAYDA);
}
if (existRequest.AccidentDetail != null)
existRequest.AccidentDetail.IsAccidentAAYDA = false;
existRequest.AAYDAStatus = InstitutionStatus.Payment_Pending;
break;
case nameof(Policies.DINBDYPIOperator):
step = StepType.dindypi_operator;
existRequest.DYPStatus = InstitutionStatus.Payment_Pending;
if (unpaidPaymentAAYDA != null)
{
AddNewPaymentStatus(existRequest, AynaStatus.Payment_Pending_AAYDA_DYP, CarrierStatus.Payment_Pending_AAYDA_DYP);
}
else AddNewPaymentStatus(existRequest, AynaStatus.Payment_Pending_DYP, CarrierStatus.Payment_Pending_DYP);
if (existRequest.AccidentDetail != null && existRequest.AccidentDetail.IsAccidentDYP != null)
existRequest.AccidentDetail.IsAccidentDYP = false;
break;
case nameof(Policies.AYNALeadership):
step = StepType.guidance_checking; break;
default:
throw new BadRequestException("Ödəniş yaratmaq üçün icazəniz yoxdur");
}
var requestStep = existRequest.RequestSteps.FirstOrDefault(x => x.Step == step.ToString());
if (requestStep == null) throw new BadRequestException("Əməliyyat düzgün aparılmadı");

PaymentGroup paymentGroup = null;
decimal amount = bulkrequest.BulkPayments.Sum(x => x.Amount);

if (step == StepType.aayda_operator && aaydaPaymentRusum == null)
{
bulkrequest.BulkPayments.Add(new SavePaymentRequest
{
AccompanyingForm = AccompanyingForm.None,
//Amount = 30,
Amount = 1,
Description = "Dövlət rüsumu"
});
amount += 1; //TODO: 30
}
if (step == StepType.aayda_operator && aaydaPayment != null)
{
aaydaPayment.TotalAmount += amount;
paymentGroup = aaydaPayment;
}
else if (step == StepType.dindypi_operator && dypPayment != null)
{
dypPayment.TotalAmount += amount;
paymentGroup = dypPayment;
}
else
{
paymentGroup = existRequest.PaymentGroups.FirstOrDefault(x => x.Name.ToUpper() == name.ToUpper());
if (paymentGroup != null) paymentGroup.TotalAmount += amount;
}
if (paymentGroup != null) paymentGroup.PaymentStatus = PaymentStatus.Pending;

if (paymentGroup == null)
{
paymentGroup = await _paymentGroupRepository.AddAsync(new PaymentGroup
{
Name = name,
TotalAmount = amount,
PaymentStatus = Core.Enums.PaymentStatus.Pending,
CreatedDate = _dateTime.Now,
Request = existRequest,
RequestId = requestId,
User = policy.User,
UserId = policy.UserId,
});
}

foreach (var request in bulkrequest.BulkPayments)
{

if (policy.Policy.Name == Policies.DINBDYPIOperator.ToString())
{
switch (request.AccompanyingForm)
{
case AccompanyingForm.EscortVehicle:
existRequest.AccompanyingForm |= AccompanyingForm.EscortVehicle;
break;
default:
throw new BadRequestException("Müşayiət forması mövcud deyil");
}
await _requestRepository.UpdateAsync(existRequest);
}
paymentGroup.Payments.Add(new Core.Entities.Concrete.Payment
{
Description = request.Description,
PaymentGroup = paymentGroup,
PaymentGroupId = paymentGroup.Id,
Name = name,
Amount = request.Amount,
AccompanyingForm = request.AccompanyingForm ?? AccompanyingForm.None,
CreatedDate = _dateTime.Now,
});
await _paymentGroupRepository.UpdateAsync(paymentGroup);

var policyName = (Policies)Enum.Parse(typeof(Policies), policy.Policy.Name);

await _notificationRepository.AddAsync(new Core.Entities.Concrete.Notification
{
Message = $"{existRequest.Id} nömrəli müraciətinizə {EnumHelper.GetEnumDescription(policyName)} tərəfindən ödəniş təyin edildi. Təsdiq üçün ödəniş edilməsi gözlənilir.",
Status = NotificationStatus.NotSeen,
CreatedDate = _dateTime.Now,
SendAt = _dateTime.Now,
User = existRequest.User,
UserId = existRequest.UserId,
Step = NotificationStatus.PaymentPending
});
await SendNotificationToSpecificPolicy(existRequest, $"{existRequest.Id} nömrəli müraciətə {EnumHelper.GetEnumDescription(policyName)} tərəfindən ödəniş təyin edildi. Təsdiq üçün ödəniş edilməsi gözlənilir."
, StepType.aynaoperator_checking, NotificationStatus.PaymentPending);
if(existRequest.User?.Phone != null)
{
string phone = "0" + existRequest.User?.Phone?.Replace("+994", "")
.Replace("-", "")
.Replace(" ", "");
await _smsService.SendMessageAsync(phone, $"{existRequest.Id} nömrəli müraciətə {EnumHelper.GetEnumDescription(policyName)} tərəfindən ödəniş təyin edildi. Təsdiq üçün ödəniş edilməsi gözlənilir.");
}
}

scope.Complete();

return new PaymentResponse { Id = paymentGroup.Id };
}
catch (Exception e)
{
throw new BadRequestException(e.Message);
}
}

private async Task SendNotification(int requestId, int userId, string message, NotificationStatus step)
{
await _notificationService.CreateNotificationAsync(new Application.Models.Notifications.SaveNotificationRequest
{
Message = message,
UserId = userId,
RequestId = requestId,
Step = step
});
}

private async Task SendNotificationToSpecificPolicy(Request request, string message, StepType step, NotificationStatus notificationStatus)
{
var users = _userRequestStepRepository.GetQuery().Include(x => x.RequestStep).Where(x => x.RequestStep.Step == step.ToString())
.Include(x => x.User)
.GroupBy(x => x.UserId)
.Select(g => g.First()).ToList();
if (users.Any())
{
foreach (var specificUser in users)
{
if (specificUser.User != null)
{
await _notificationRepository.AddAsync(new Core.Entities.Concrete.Notification
{
Message = message,
CreatedDate = _dateTime.Now,
SendAt = _dateTime.Now,
Status = NotificationStatus.NotSeen,
User = specificUser.User,
UserId = specificUser.UserId,
Step = notificationStatus,
RequestId = request.Id
});
}
}
}
}

private async Task<Core.Entities.Concrete.UserPolicy> GetUserPolicy()
{
var currentUser = await _userService.GetCurrentUser(false);
if (currentUser == null) throw new Exception("İstifadəçi tapılmadı");
var policy = currentUser.UserPolicies.FirstOrDefault();
if (policy == null) throw new Exception("Səlahiyyət tapılmadı");
return policy;
}

private async Task DeleteExistingPayment(int requestId, int userId)
{
var existingPayments = await _paymentGroupRepository.GetAllAsync(p => p.RequestId == requestId && p.UserId == userId);
foreach (var existingPayment in existingPayments)
{
await _paymentGroupRepository.HardDeleteAsync(existingPayment);
}
}
public async Task<PaymentRequest> CreatePaymentRequest(Request request, string name, decimal amount, List<string> descriptions, string policyName)
{
if (amount < 1) throw new BadRequestException("Ödəniş miqdarı 0 - dan böyük olmalıdır.");
var paymentRequest = new PaymentRequest
{
PaymentTypeId = 1,
SystemRecordId = request.Id.ToString(),
PaymentChannelId = 1,
Lang = "az",
Products = new Product[]
{
new Product
{
Name = name,
Description = string.Join(",", descriptions),
Price = amount,
Discount = 0
}
},
Client = new Client
{
FullName = $"{request.User.FirstName} {request.User.LastName} {request.User.FatherName}",
Description = policyName,
CardNumber = "4268631215123689"
}
};
return paymentRequest;
}
public async Task<GetPaymentResponse> GeneratePaymentLink(int requestId, int paymentGroupId)
{
var userPolicy = await _userService.GetUserPolicy();
if (userPolicy.Policy.Name != Policies.Carrier.ToString()) throw new BadRequestException("Sizin bu əməliyyat üçün icazəniz yoxdur");
var request = await _requestService.GetRequestByIdWithNoTracking(requestId);
var paymentGroup = await _paymentGroupRepository.GetQuery()
.Include(x => x.Payments)
.FirstOrDefaultAsync(x => x.Id == paymentGroupId && x.RequestId == requestId);
if (paymentGroup == null) throw new BadRequestException("Ödəniş tapılmadı");
if (paymentGroup.PaymentStatus == PaymentStatus.Paid) throw new BadRequestException("Artıq ödəniş olunmuşdur");
var descriptions = paymentGroup.Payments.Select(x => x.Description).ToList();
var amount = paymentGroup.Payments?.Where(x => x.PaymentStatus != PaymentStatus.Paid).Sum(x => x.Amount) ?? 0;
var paymentRequest = await CreatePaymentRequest(request, paymentGroup.Name, amount, descriptions, paymentGroup.Name);
PaymentGetDto data = await GeneratePaymentDto(paymentRequest);
paymentGroup.PaymentUrl = data.PaymentUrl;
paymentGroup.PaymentId = data.Id;
await _paymentGroupRepository.UpdateAsync(paymentGroup);
return new GetPaymentResponse { PaymentUrl = paymentGroup.PaymentUrl };
}

private static void AddNewPaymentStatus(Request existRequest, AynaStatus newAynaStatus, CarrierStatus newCarrierStatus)
{
CarrierStatus remainingStatuses = existRequest.Status;
AynaStatus remainingStatusesAyna = existRequest.AynaStatus;
CarrierStatus paymentMask = CarrierStatus.Payment_Pending_AAYDA_DYP |
CarrierStatus.Payment_Pending_AAYDA |
CarrierStatus.Payment_Pending_AYNA |
CarrierStatus.Payment_Pending_DYP;
AynaStatus paymentMaskAyna = AynaStatus.Payment_Pending_AAYDA_DYP |
AynaStatus.Payment_Pending_AAYDA |
AynaStatus.Payment_Pending_AYNA |
AynaStatus.Payment_Pending_DYP;

CarrierStatus paymentStatuses = existRequest.Status & paymentMask;
remainingStatuses = existRequest.Status & ~paymentStatuses;


if (newCarrierStatus == CarrierStatus.Payment_Pending_AAYDA)
{
if ((existRequest.Status & CarrierStatus.Watching_AAYDA_And_DYP) == CarrierStatus.Watching_AAYDA_And_DYP)
{
remainingStatuses = remainingStatuses & ~CarrierStatus.Watching_AAYDA_And_DYP;
remainingStatuses |= CarrierStatus.Watching_DYP;
}
remainingStatuses = remainingStatuses & ~CarrierStatus.Watching_AAYDA;
}
else if (newCarrierStatus == CarrierStatus.Payment_Pending_DYP)
{
if ((existRequest.Status & CarrierStatus.Watching_AAYDA_And_DYP) == CarrierStatus.Watching_AAYDA_And_DYP)
{
remainingStatuses = remainingStatuses & ~CarrierStatus.Watching_AAYDA_And_DYP;
remainingStatuses |= CarrierStatus.Watching_AAYDA;
}
remainingStatuses = remainingStatuses & ~CarrierStatus.Watching_DYP;
}
else if (newCarrierStatus == CarrierStatus.Payment_Pending_AAYDA_DYP)
{
remainingStatuses = remainingStatuses & ~CarrierStatus.Watching_AAYDA_And_DYP & ~CarrierStatus.Watching_AAYDA & ~CarrierStatus.Watching_DYP;
}

existRequest.Status = remainingStatuses | newCarrierStatus;



AynaStatus paymentStatusesAyna = existRequest.AynaStatus & paymentMaskAyna;


remainingStatusesAyna = existRequest.AynaStatus & ~paymentStatusesAyna;
if (newAynaStatus == AynaStatus.Payment_Pending_AAYDA)
{
if ((existRequest.AynaStatus & AynaStatus.Watching_AAYDA_And_DYP) == AynaStatus.Watching_AAYDA_And_DYP)
{
remainingStatusesAyna = remainingStatusesAyna & ~AynaStatus.Watching_AAYDA_And_DYP;
remainingStatusesAyna |= AynaStatus.Watching_DYP;
}
remainingStatusesAyna = remainingStatusesAyna & ~AynaStatus.Watching_AAYDA;
}
else if (newAynaStatus == AynaStatus.Payment_Pending_DYP)
{
if ((existRequest.AynaStatus & AynaStatus.Watching_AAYDA_And_DYP) == AynaStatus.Watching_AAYDA_And_DYP)
{
remainingStatusesAyna = remainingStatusesAyna & ~AynaStatus.Watching_AAYDA_And_DYP;
remainingStatusesAyna |= AynaStatus.Watching_AAYDA;
}
remainingStatusesAyna = remainingStatusesAyna & ~AynaStatus.Watching_DYP;
}
else if (newAynaStatus == AynaStatus.Payment_Pending_AAYDA_DYP)
{
remainingStatusesAyna = remainingStatusesAyna & ~AynaStatus.Watching_AAYDA_And_DYP & ~AynaStatus.Watching_AAYDA & ~AynaStatus.Watching_DYP;
}
existRequest.AynaStatus = remainingStatusesAyna | newAynaStatus;

}
private async Task ChangeStatusesWhenPaid(Request existsRequest, string name)
{
(CarrierStatus carrierStatus, AynaStatus aynaStatus) statusesAYNA = (existsRequest.Status, existsRequest.AynaStatus);
(CarrierStatus carrierStatus, AynaStatus aynaStatus) statusesAAYDA = (existsRequest.Status, existsRequest.AynaStatus);
(CarrierStatus carrierStatus, AynaStatus aynaStatus) statusesDYP = (existsRequest.Status, existsRequest.AynaStatus);

switch (name)
{
case "AAYDA":
statusesAAYDA = NameAAYDAUpdate(existsRequest);
existsRequest.Status = statusesAAYDA.carrierStatus;
existsRequest.AynaStatus = statusesAAYDA.aynaStatus;
await SendNotificationToSpecificPolicy(existsRequest, $"{existsRequest.Id} nömrəli müraciətin AAYDA ödənişi daşıyıcı tərəfindən ödənildi.",
StepType.aayda_operator, NotificationStatus.Sent);
await SendNotification(existsRequest.Id, existsRequest.UserId, "AAYDA-nın ödənişi uğurla tamamlandı.", NotificationStatus.Sent);
break;
case "DIN BDYPI":
statusesDYP = NameDINBDYPIUpdate(existsRequest);
existsRequest.Status = statusesDYP.carrierStatus;
existsRequest.AynaStatus = statusesDYP.aynaStatus;
await SendNotificationToSpecificPolicy(existsRequest, $"{existsRequest.Id} nömrəli müraciətin DYP ödənişi daşıyıcı tərəfindən ödənildi.",
StepType.dindypi_operator, NotificationStatus.Sent);
await SendNotification(existsRequest.Id, existsRequest.UserId, "DYP-nın ödənişi uğurla tamamlandı.", NotificationStatus.Sent);
break;
case "AYNA":
existsRequest.Status = CarrierStatus.Watching_AYNA;
existsRequest.AynaStatus = AynaStatus.Approving;
await SendNotificationToSpecificPolicy(existsRequest, $" {existsRequest.Id} nömrəli müraciətin AYNA ödənişi daşıyıcı tərəfindən ödənildi. İcazə üçün təsdiq gözləyir.", StepType.guidance_checking, NotificationStatus.Sent);
await SendNotification(existsRequest.Id, existsRequest.UserId, "AYNA-nın ödənişi uğurla tamamlandı.", NotificationStatus.Sent);
break;
default: throw new BadRequestException("Ödəniş tapılmadı");
}
}
(CarrierStatus carrier, AynaStatus ayna) NameAAYDAUpdate(Request existsRequest)
{
CarrierStatus newCarrierStatus;
AynaStatus newAynaStatus;

existsRequest.AAYDAStatus = InstitutionStatus.Pending;
switch (existsRequest.Status)
{
case var s when (s & CarrierStatus.Payment_Pending_AAYDA_DYP) == CarrierStatus.Payment_Pending_AAYDA_DYP:
newCarrierStatus = (s & ~CarrierStatus.Payment_Pending_AAYDA_DYP) | CarrierStatus.Payment_Pending_DYP;
newAynaStatus = (existsRequest.AynaStatus & ~AynaStatus.Payment_Pending_AAYDA_DYP) | AynaStatus.Payment_Pending_DYP;
break;


case var s when (s & CarrierStatus.Payment_Pending_AAYDA) == CarrierStatus.Payment_Pending_AAYDA:
CarrierStatus carrierStatus = CarrierStatus.Watching_AAYDA;
AynaStatus aynaStatus = AynaStatus.Watching_AAYDA;
if ((existsRequest.Status & CarrierStatus.Watching_DYP) == CarrierStatus.Watching_DYP)
{
carrierStatus = CarrierStatus.Watching_AAYDA_And_DYP;
aynaStatus = AynaStatus.Watching_AAYDA_And_DYP;
}
newCarrierStatus = (s & ~CarrierStatus.Payment_Pending_AAYDA) | carrierStatus;
newAynaStatus = (existsRequest.AynaStatus & ~AynaStatus.Payment_Pending_AAYDA) | aynaStatus;
break;

default:
newCarrierStatus = existsRequest.Status;
newAynaStatus = existsRequest.AynaStatus;
break;
}

return (newCarrierStatus, newAynaStatus);
}

(CarrierStatus carrier, AynaStatus ayna) NameDINBDYPIUpdate(Request existsRequest)
{
existsRequest.DYPStatus = InstitutionStatus.Pending;

CarrierStatus newCarrierStatus;
AynaStatus newAynaStatus;
switch (existsRequest.Status)
{

case var s when (s & CarrierStatus.Payment_Pending_AAYDA_DYP) == CarrierStatus.Payment_Pending_AAYDA_DYP:
newCarrierStatus = (s & ~CarrierStatus.Payment_Pending_AAYDA_DYP) | CarrierStatus.Payment_Pending_AAYDA;
newAynaStatus = (existsRequest.AynaStatus & ~AynaStatus.Payment_Pending_AAYDA_DYP) | AynaStatus.Payment_Pending_AAYDA;
break;

case var s when (s & CarrierStatus.Payment_Pending_DYP) == CarrierStatus.Payment_Pending_DYP:
CarrierStatus carrierStatus = CarrierStatus.Watching_DYP;
AynaStatus aynaStatus = AynaStatus.Watching_DYP;
if ((existsRequest.Status & CarrierStatus.Watching_AAYDA) == CarrierStatus.Watching_AAYDA)
{
carrierStatus = CarrierStatus.Watching_AAYDA_And_DYP;
aynaStatus = AynaStatus.Watching_AAYDA_And_DYP;
}
newCarrierStatus = (s & ~CarrierStatus.Payment_Pending_DYP) | carrierStatus;
newAynaStatus = (existsRequest.AynaStatus & ~AynaStatus.Payment_Pending_DYP) | aynaStatus;
break;

default:
newCarrierStatus = existsRequest.Status;
newAynaStatus = existsRequest.AynaStatus;
break;
}
return (newCarrierStatus, newAynaStatus);
}
}