Service Layer

namespace _____
{
    [SessionRequestFilter]
    public class AdminService : Service
    {
        private readonly ICacheClient _cache;
        private readonly JetonPaymentService _jetonService;
        private readonly AsanaService _asanaService;
        private readonly RocketPaymentService _rocketService;
        private readonly ILogger _logger = Log.ForContext<AdminService>();
        private readonly DbRepo _repo;
        private readonly IMailService _mailService;
        private readonly IRedisService _redisService;

        public AdminService(DbRepo repo, ICacheClient cache, JetonPaymentService jetonService, AsanaService asanaService, RocketPaymentService rocketService, IMailService mailService, IRedisService redisService)
        {
            _cache = cache;
            _repo = repo;
            _mailService = mailService;
            _jetonService = jetonService;
            _asanaService = asanaService;
            _rocketService = rocketService;
            _redisService = redisService;
        }

        public async Task<object> Any(UpdateWithdrawRocketTransferRequest request)
        {
            _logger.Information("UpdateWithdrawRocketTransferRequest : UserId : {userId} , Lang : {lang}, {request}", Request.UserId(), Request.Lang(), request.SerializeToString());

            var withdrawDetails = await _repo.WithdrawRocketTransferDetail(request.Id);

            var result = await _repo.UpdateWithdrawRocketTransfer(Request.Lang(), Request.UserId(), request.SiteId,
                    request.Id, request.Status, request.CancelReason);

            if (request.Status != 2 || withdrawDetails.Status == 2) return Request.ToOptimizedResult(result);
            var updatedDetails = await _repo.WithdrawRocketTransferDetail(request.Id);
            if (updatedDetails.Status != 2) return Request.ToOptimizedResult(result);

            try
            {
                var withdrawResponse = await _rocketService.WithdrawRequest(withdrawDetails.BankId, request.Id.ToString(), withdrawDetails.PlayerId.ToString(),
                withdrawDetails.Username, withdrawDetails.RequestAmount, withdrawDetails.Iban, "");
            }
            catch (Exception e)
            {
                await _repo.UpdateWithdrawRocketTransfer(Request.Lang(), Request.UserId(), request.SiteId,
                    request.Id, 3, e.Message);
                throw e;
            }

            return Request.ToOptimizedResult(result);
        }

        public async Task<object> Any(AccountingPlayersWithSameIpRequest request)
        {
            _logger.Information("AccountingPlayersWithSameIpRequest : UserId : {userId} , Lang : {lang}, {request}",
                Request.UserId(), Request.Lang(), request.SerializeToString());
            var result = await _repo.AccountingPlayersWithSameIp(request.PlayerId);
            return Request.ToOptimizedResult(result);
        }

        public async Task<object> Any(CreateNewDynamicFormRequest req)
        {
            return Request.ToOptimizedResult(await _repo.CreateNewDynamicForm(req.Id, req.SiteId, req.Name, req.Lang, Request.Lang(), req.Currency, req.Active, req.ImageURL));
        }
        public async Task<object> Any(SiteTournamentMarketRequest req)
        {
            return Request.ToOptimizedResult(await _repo.SiteTournamentMarkets(Request.Lang(), req.SiteId, req.TournamentId, req.Live));
        }
        public async Task<object> Any(UpdateSiteTournamentMarketRequest req)
        {
            return Request.ToOptimizedResult(await _repo.UpdateSiteTournamentMarket(Request.Lang(), req.SiteId, req.MarketId, req.TournamentId, req.PrematchActive, req.LiveActive, req.OddsKey1, req.OddsKey2, req.OddsKey3, req.MinimumOffer, req.MaximumCap, req.Intervals));
        }
        public async Task<object> Any(SiteCategoryMarketRequest request)
        {
            _logger.Information("SiteCategoryMarketRequest : UserId : {userId} , Lang : {lang}, {request}",
               Request.UserId(), Request.Lang(), request.SerializeToString());

            var result = await _repo.SiteCategoryMarkets(Request.Lang(), request.SiteId, request.CategoryId, request.Live);
            return Request.ToOptimizedResult(result);
        }
        public async Task<object> Any(UpdateSiteCategoryMarketRequest request)
        {
            _logger.Information("UpdateSiteCategoryMarketRequest : UserId : {userId} , Lang : {lang}, {request}",
                Request.UserId(), Request.Lang(), request.SerializeToString());
            var result = await _repo.UpdateSiteCategoryMarket(Request.Lang(), request.SiteId, request.MarketId, request.CategoryId, request.PrematchActive, request.LiveActive, request.OddsKey1, request.OddsKey2, request.OddsKey3, request.MinimumOffer, request.MaximumCap, request.Intervals);
            return Request.ToOptimizedResult(result);
        }

        public async Task<object> Any(SiteSportMarketRequest request)
        {
            _logger.Information("SiteSportMarketRequest : UserId : {userId} , Lang : {lang}, {request}",
               Request.UserId(), Request.Lang(), request.SerializeToString());
            var result = await _repo.SiteSportMarkets(Request.Lang(), request.SiteId, request.SportId, request.Live);
            return Request.ToOptimizedResult(result);
        }
    }
}