public override async Task <RequestResult <TenantSettingsDto> > Handle(
            UpdateTenantSettingsCommand request, CancellationToken cancellationToken)
        {
            var tenant = await _tenantsRepository.GetTenantAsync(request.TenantCode);

            if (tenant == null)
            {
                return(RequestResult <TenantSettingsDto> .Failure(ErrorCode.TenantNotFound,
                                                                  new { request.TenantCode }));
            }

            var saveData = _mapper.Map <SaveTenantSettingsData>(request);

            saveData.TenantId = tenant.Id;
            var tenantSettings = await _tenantSettingsRepository.SaveTenantSettings(saveData);

            if (tenantSettings == null)
            {
                return(RequestResult <TenantSettingsDto> .Failure(ErrorCode.UpdateTenantSettingsFailed));
            }

            if (!await _allowedOriginsRepository.SaveAllowedOriginsAsync(tenant.Id, request.AllowedOrigins))
            {
                return(RequestResult <TenantSettingsDto> .Failure(ErrorCode.UpdateTenantSettingsFailed));
            }

            return(RequestResult <TenantSettingsDto>
                   .Success(_mapper.Map <TenantSettingsDto>(tenantSettings)));
        }
        public async Task <TenantDto> InitializeTenantFromConfigurationAsync()
        {
            var config = _adminTenantConfiguration;

            try
            {
                using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    var tenant = await _tenantsRepository.GetTenantAsync(config.TenantCode);

                    var requestContext = new RequestContext()
                                         .WithSystemAdminContext();

                    if (tenant != null)
                    {
                        return(_mapper.Map <TenantDto>(tenant));
                    }

                    var correlationId = await CreateTenant(config, requestContext);

                    tenant = await _tenantsRepository.GetTenantAsync(config.TenantCode);

                    var createUserResult = await CreateUser(config, tenant, correlationId);

                    await MakeUserAdmin(createUserResult.Data.UserGuid, requestContext, correlationId);

                    await MakeUserTenantOwner(createUserResult.Data.UserGuid, requestContext, correlationId);

                    transactionScope.Complete();
                    return(_mapper.Map <TenantDto>(tenant));
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
            }

            return(null);
        }
        public async Task <Tenant> GetTenantAsync(string tenantCode)
        {
            var result = await _cache.GetOrCreateAsync($"{CacheConstants.TenantCachePrefix}{tenantCode}",
                                                       async (ce) =>
            {
                ce.SlidingExpiration  = TimeSpan.FromMinutes(5);
                ce.AbsoluteExpiration = DateTime.Now.AddHours(1);

                var tenant = await _tenantsRepository.GetTenantAsync(tenantCode);
                if (tenant == null)
                {
                    throw new DomainException(ErrorCode.TenantNotFound, new { tenantCode });
                }

                return(tenant);
            });

            return(result);
        }