App_V2.3/SourceCode/WeApp.Application/BaseSystem/Settings/SettingsAppService.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Abp;
using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Configuration;
using Abp.Configuration.Startup;
using Abp.Domain.Repositories;
using Abp.Domain.Uow;
using Abp.Localization.Dictionaries;
using Abp.Runtime.Caching;
using WeApp.Authorization;
using WeApp.BaseSystem.Settings.Dto;
using WeApp.Configuration;
using WeApp.Localization;
using IwbZero;
using IwbZero.AppServiceBase;
using IwbZero.Auditing;
using IwbZero.Authorization.Base.SystemInfo;
using IwbZero.Authorization.Base.Users;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;
using WeApp.Authorization.Users;

namespace WeApp.BaseSystem.Settings
{
    [AbpAuthorize, AuditLog("系统配置", "配置")]
    public class SettingsAppService : IwbAsyncCrudAppService<SysSetting, SettingDto, long, IwbPagedRequestDto, SettingCreateDto, SettingUpdateDto>, ISettingsAppService
    {
        private ILocalizationConfiguration Configuration { get; }

        public SettingsAppService(ICacheManager cacheManager, IRepository<SysSetting, long> repository, ILocalizationConfiguration configuration) : base(repository, "")
        {
            Configuration = configuration;
            CacheManager = cacheManager;
        }
        protected override string KeyExistMessage => string.Format(L(IwbLanguageMessage.KeyExistMessageFormatter), L("setting"));
        protected override string KeyNotExistMessage => string.Format(L(IwbLanguageMessage.KeyNotExistMessageFormatter), L("setting"));

        #region Setting

        [AbpAuthorize(PermissionNames.PagesUserSysSettingLoginImage), AuditLog("配置登陆背景")]
        public async Task LoginImage(ImageDto input)
        {
            //超级管理员和管理员才可操作
            //if (AbpSession.UserType != UsersAndRolesTypeDefinition.Supper )
            //{
            //    ThrowError(WeAppLanguageMessage.NoPermissionOperation);
            //}
            if (input.ImageInfo.IsEmpty())
            {
                ThrowError(IwbLanguageMessage.NoImageInfo);
            }

            await AttachFileManager.FileUpload(input.ImageInfo, await GetLoginHomePath(IwbSettingNames.LoginPagePath), IwbConsts.LoginImageName, IwbConsts.LoginHomeImageExt);
        }

        [AbpAuthorize(PermissionNames.PagesUserSysSettingHomeImage), AuditLog("配置主页背景")]
        public async Task HomeImage(ImageDto input)
        {
            //超级管理员和管理员才可操作
            //if (AbpSession.UserType != UsersAndRolesTypeDefinition.Supper )
            //{
            //    ThrowError(WeAppLanguageMessage.NoPermissionOperation);
            //}
            if (input.ImageInfo.IsEmpty())
            {
                ThrowError(IwbLanguageMessage.NoImageInfo);
            }
            await AttachFileManager.FileUpload(input.ImageInfo, await GetLoginHomePath(IwbSettingNames.HomePagePath),
                IwbConsts.HomeImageName, IwbConsts.LoginHomeImageExt);
        }

        private async Task<string> GetLoginHomePath(string name)
        {
            int? tenantId = AbpSession.TenantId;
            long userId = AbpSession.UserId ?? 0;
            var path = await SettingManager.GetSettingValueAsync(name);
            if (tenantId.HasValue && !path.EndsWith(tenantId + "") && !path.EndsWith(tenantId + "/"))
            {
                if (AbpSession.UserName != UserBase.AdminUserName)
                {
                    path = $"{path}/{tenantId}/{userId}";
                    await SettingManager.ChangeSettingForUserAsync(new UserIdentifier(tenantId, userId), name, path);
                }
            }

            return path;
        }

        [AbpAuthorize(PermissionNames.PagesUserSysSettingRefreshCache), AuditLog("刷新缓存")]
        public async Task CacheRefresh(string id)
        {
            //超级管理员和管理员才可操作
            if (AbpSession.UserType != UsersAndRolesTypeDefinition.Supper && AbpSession.UserType != UsersAndRolesTypeDefinition.System)
            {
                ThrowError(IwbLanguageMessage.NoPermissionOperation);
            }
            if (string.IsNullOrEmpty(id))
            {
                foreach (var cacheName in IwbCacheNames.RefreshList)
                {
                    var cache = CacheManager.GetCache(cacheName);
                    await cache.ClearAsync();
                }
            }
            else
            {
                var cache = CacheManager.GetCache(id);
                await cache.ClearAsync();
            }
        }
        [AbpAuthorize(PermissionNames.PagesUserSysSettingRefreshLang), AuditLog("刷新语言包")]
        public void LangRefresh()
        {
            //超级管理员才可操作
            if (AbpSession.UserType != UsersAndRolesTypeDefinition.Supper)
            {
                ThrowError(IwbLanguageMessage.NoPermissionOperation);
            }
            foreach (var source in Configuration.Sources)
            {
                if (source.Name != IwbZeroConsts.LocalizationSourceName)
                {
                    continue;
                }

                //Extending dictionaries
                if (source is IDictionaryBasedLocalizationSource dictionaryBasedSource)
                {
                    var extensions = Configuration.Sources.Extensions.Where(e => e.SourceName == source.Name).ToList();
                    foreach (var extension in extensions)
                    {
                        if (extension.DictionaryProvider is IwbXmlFileLocalizationDictionaryProvider provider)
                        {
                            provider.Refresh(dictionaryBasedSource.Name);
                            foreach (var extensionDictionary in provider.Dictionaries.Values)
                            {
                                dictionaryBasedSource.Extend(extensionDictionary);
                            }
                        }
                    }
                }
                this.LogDebug("Refreshed localization source: " + source.Name);
            }
        }


        #endregion

        #region CURD

        //[AbpAuthorize(PermissionNames.PagesSystemMgSettingMgCreate)]
        //public override async Task Create(SettingCreateDto input)
        //{
        //    ThrowError(WeAppLanguageMessage.NoPermissionOperation);
        //    //超级管理员才可操作
        //    if (AbpSession.UserType != UsersAndRolesTypeDefinition.Supper)
        //    {
        //        ThrowError(WeAppLanguageMessage.NoPermissionOperation);
        //    }
        //    input.Type = SystemSettingTypeDefinition.User;
        //    if ((await Repository.FirstOrDefaultAsync(a => a.Name == input.Name)) != null)
        //        CheckErrors(ExistMessage);
        //    var entity = MapToEntity(input);
        //    await Repository.InsertAsync(entity);
        //}
        [AbpAuthorize(PermissionNames.PagesSystemMgSettingMgUpdate)]
        public override async Task Update(SettingUpdateDto input)
        {
            //var entity = await Repository.FirstOrDefaultAsync(a => a.Name == input.Name&& a.TenantId==tenantId);
            //if (entity == null)
            //    CheckErrors(NotExistMessage);
            //else
            //{
            //    input.Name = entity.Name;
            //    input.Type = entity.Type;
            //}
            //MapToEntity(input, entity);
            //await CurrentUnitOfWork.SaveChangesAsync();
            if (AbpSession.TenantId.HasValue)
            {
                var value = await SettingManager.GetSettingValueAsync(input.Name);
                if (input.Value != value)
                {
                    await SettingManager.ChangeSettingForTenantAsync((int)AbpSession.TenantId, input.Name, input.Value);
                }
            }
            else
            {
                await SettingManager.ChangeSettingForApplicationAsync(input.Name, input.Value);
            }
        }
        //[AbpAuthorize(PermissionNames.PagesSystemMgSettingMgDelete)]
        //public override async Task Delete(EntityDto<long> input)
        //{
        //    ThrowError(WeAppLanguageMessage.NoPermissionOperation);

        //    //超级管理员Admin、System才可操作
        //    if (AbpSession.UserName!=UserBase.AdminUserName&&AbpSession.UserName!=UserBase.SystemUserName)
        //    {
        //        ThrowError(WeAppLanguageMessage.NoPermissionOperation);
        //    }
        //    await Repository.DeleteAsync(input.Id);
        //}
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesSystemMgSettingMgQuery)]
        public override async Task<PagedResultDto<SettingDto>> GetAll(IwbPagedRequestDto input)
        {
            CheckGetAllPermission();
            //var query = CreateFilteredQuery(input);
            //if (AbpSession.TenantId.HasValue&& (AbpSession.UserName!=UserBase.HostAdminName|| AbpSession.UserName!=UserBase.HostSystemName))
            //{
            //    query= query.Where(a => a.Type > 0);
            //}

            //query = ApplyFilter(query, input);
            //var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            //query = ApplySorting(query, input);
            //query = ApplyPaging(query, input);
            //var entities = await AsyncQueryableExecuter.ToListAsync(query);
            //var dtoList = new PagedResultDto<SettingDto>(
            //    totalCount,
            //    entities.Select(MapToEntityDto).ToList()
            //);
            //return dtoList;
            int totalCount;
            List<SysSetting> entities;
            using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.MayHaveTenant))
            {
                var query = CreateFilteredQuery(input).Where(a =>
                    (AbpSession.UserName == UserBase.HostAdminName || AbpSession.UserName == UserBase.HostSystemName ||
                     // ReSharper disable once RedundantLogicalConditionalExpressionOperand
                     a.Type == SystemSettingTypeDefinition.Tenant) && (a.TenantId == null || (a.TenantId == 1 && !IwbConsts.MultiTenancyEnabled)));
                query = ApplyFilter(query, input);
                totalCount = await AsyncQueryableExecuter.CountAsync(query);
                query = ApplySorting(query, input);
                query = ApplyPaging(query, input);
                entities = await AsyncQueryableExecuter.ToListAsync(query);

            }
            var dtoList = new PagedResultDto<SettingDto>(
                totalCount,
                entities.Select(MapEntityToDto).ToList()
            );
            return dtoList;
        }

        private SettingDto MapEntityToDto(SysSetting entity)
        {
            var dto = MapToEntityDto(entity);
            dto.Value = SettingManager.GetSettingValue(entity.Name);
            return dto;
        }

        #endregion

    }
}