WEP_V2.1.3/SourceCode/We.AppOnline/WeOnlineApp.Application/Question/QuestionApplicationService.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Mvc;
using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;
using IwbZero.Auditing;
using IwbZero.AppServiceBase;
using IwbZero.ToolCommon.Lambda;
using WeOnlineApp.Authorization.Users;
using WeOnlineApp.Configuration;
using WeOnlineApp.Question.Dto;
using WeOnlineApp.TrainingCamp;
using IwbZero.ToolCommon.StringModel;

namespace WeOnlineApp.Question
{
    [AbpAuthorize, AuditLog("问题")]
    public class QuestionAppService : IwbAsyncCrudAppService<QuestionInfo, QuestionDto, string, IwbPagedRequestDto, QuestionCreateDto, QuestionUpdateDto >, IQuestionAppService
    {
        public QuestionAppService(
			ICacheManager cacheManager,
			IRepository<QuestionInfo, string> repository, IRepository<QuestionAnswerInfo,string> qaRepository, IRepository<CampInfo, string> campRepository, IRepository<User, long> userRepository, IRepository<QuestionFavoriteInfo> qfRepository) : base(repository, "Id")
        {
            QaRepository = qaRepository;
            CampRepository = campRepository;
            UserRepository = userRepository;
            QfRepository = qfRepository;
            CacheManager = cacheManager;
        }

        protected override bool KeyIsAuto { get; set; } = false;

        protected IRepository<QuestionAnswerInfo,string> QaRepository { get; }
        protected IRepository<CampInfo,string> CampRepository { get; }
        protected IRepository<QuestionFavoriteInfo> QfRepository { get; }
        protected IRepository<User,long> UserRepository { get; }

        #region GetSelect

        [DisableAuditing]
        public override async Task<List<SelectListItem>> GetSelectList()
        {
            var list = await Repository.GetAllListAsync();
            var sList = new List<SelectListItem> {new SelectListItem {Text = @"请选择...", Value = "", Selected = true}};
            foreach (var l in list)
            {
                //sList.Add(new SelectListItem { Value = l.Id, Text = l. });
            }
            return sList;
        }
        [DisableAuditing]
        public override async Task<string> GetSelectStr()
        {
            var list = await Repository.GetAllListAsync();
            string str = "<option value=\"\" selected>请选择...</option>";
            foreach (var l in list)
            {
                //str += $"<option value=\"{l.Id}\">{l.}</option>";
            }
            return str;
        }

        #endregion

        #region CURD

        //[AbpAuthorize(PermissionNames.PagesQuestionMgCreate)]
        [AuditLog("提问")]
        public override async Task Create(QuestionCreateDto input)
        {
            var camp = await CampRepository.FirstOrDefaultAsync(a => a.Id == input.CampNo);
            if (camp != null)
            {
                input.SubjectCategoryNo = camp.SubjectType;
            }
            input.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.Question);
            input.QuestionState = QuestionStateDefinition.New;
            await CreateEntity(input);
        }

        //[AbpAuthorize(PermissionNames.PagesQuestionMgUpdate)]
        public override async Task Update(QuestionUpdateDto input)
        {
            await UpdateEntity(input);
        }

        //[AbpAuthorize(PermissionNames.PagesQuestionMgDelete)]
        public override Task Delete(EntityDto<string> input)
        {
            return DeleteEntity(input);
        }

        [DisableAuditing]
        //[AbpAuthorize(PermissionNames.PagesQuestionMgQuery)]
        public override async Task<PagedResultDto<QuestionDto>> GetAll(IwbPagedRequestDto input)
        {
            var query = CreateFilteredQuery(input);
            //query = ApplyFilter(query, input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = ApplySorting(query, input);
            query = ApplyPaging(query, input);
            var q1 = query.Select(a => new QuestionDto()
            {
                Id = a.Id,
                Title = a.Title,
                QuestionState = a.QuestionState,
                AnswerDateTime = a.AnswerDateTime,
                IsFavorite = false,
                SubjectCategoryNo = a.SubjectCategoryNo,
                SubjectCategoryName = a.SubjectCategory.CategoryName,
                CampName = a.Camp.Name
            }); ;
            var entities = await AsyncQueryableExecuter.ToListAsync(q1);
            var dtoList = new PagedResultDto<QuestionDto>(totalCount, entities);
            return dtoList;
        }

		#region GetEntity/Dto

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        //[AbpAuthorize(PermissionNames.PagesQuestionMgQuery)]
        public override async Task<QuestionDto> GetDto(EntityDto<string> input)
        {
            var entity = await GetEntity(input);
            return MapToEntityDto(entity);
        }

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        //[AbpAuthorize(PermissionNames.PagesQuestionMgQuery)]
        public override async Task<QuestionDto> GetDtoById(string id)
        {
            var entity = await GetEntityById(id);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体Dto（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        //[AbpAuthorize(PermissionNames.PagesQuestionMgQuery)]
        public override async Task<QuestionDto> GetDtoByNo(string no)
        {
            var entity = await GetEntityByNo(no);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        //[AbpAuthorize(PermissionNames.PagesQuestionMgQuery)]
        public override async Task<QuestionInfo> GetEntity(EntityDto<string> input)
        {
            var entity = await GetEntityById(input.Id);
            return entity;
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        //[AbpAuthorize(PermissionNames.PagesQuestionMgQuery)]
        public override async Task<QuestionInfo> GetEntityById(string id)
        {
            return await Repository.FirstOrDefaultAsync(a=>a.Id==id);
        }

        /// <summary>
        /// 查询实体（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        //[AbpAuthorize(PermissionNames.PagesQuestionMgQuery)]
        public override async Task<QuestionInfo> GetEntityByNo(string no)
        {
            //CheckGetPermission();
            if (string.IsNullOrEmpty(KeyFiledName))
            {
                ThrowError("NoKeyFieldName");
            }
            return await base.GetEntityByNo(no);
        }

        #endregion

        #region Hide

        /// <summary>
        /// 根据给定的<see cref="IwbPagedRequestDto"/>创建 <see cref="IQueryable{QuestionInfo}"/>过滤查询.
        /// </summary>
        /// <param name="input">The input.</param>
        protected override IQueryable<QuestionInfo> CreateFilteredQuery(IwbPagedRequestDto input)
        {
            var query = Repository.GetAllIncluding(a=>a.SubjectCategory,a=>a.Camp,a=>a.Favorites);
            var pagedInput = input as IIwbPagedRequest;
            if (pagedInput == null)
            {
                return query;
            }

            query = query.Where(a =>
                string.IsNullOrEmpty(input.KeyWords) || a.SubjectCategory.CategoryPath.Contains(input.KeyWords));
            if (!string.IsNullOrEmpty(input.KeyField))
            {
                query = query.Where(a => a.Favorites.Count(s => s.UserId == AbpSession.UserId) > 0);
            }

            if (pagedInput.SearchList != null && pagedInput.SearchList.Count > 0)
            {
                List<LambdaObject> objList = new List<LambdaObject>();
                foreach (var o in pagedInput.SearchList)
                {
                    if (string.IsNullOrEmpty(o.KeyWords))
                        continue;
                    object keyWords = o.KeyWords;
                    objList.Add(new LambdaObject
                    {
                        FieldType = (LambdaFieldType)o.FieldType,
                        FieldName = o.KeyField,
                        FieldValue = keyWords,
                        ExpType = (LambdaExpType)o.ExpType
                    });
                }
                var exp = objList.GetExp<QuestionInfo>();
                query = exp != null ? query.Where(exp) : query;
            }
            return query;
        }



        //protected override IQueryable<QuestionInfo> ApplySorting(IQueryable<QuestionInfo> query, IwbPagedRequestDto input)
        //{
        //    return query.OrderBy(a => a.No);
        //}

        //protected override IQueryable<QuestionInfo> ApplyPaging(IQueryable<QuestionInfo> query, IwbPagedRequestDto input)
        //{
        //    if (input is IPagedResultRequest pagedInput)
        //    {
        //        return query.Skip(pagedInput.SkipCount).Take(pagedInput.MaxResultCount);
        //    }
        //    return query;
        //}

        #endregion

        #endregion

        /// <summary>
        /// 查询问题详情
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<QuestionDto> GeQuestionDetail(string no)
        {
            var entity = await Repository.GetAllIncluding(a => a.Camp, a => a.SubjectCategory,a=>a.AnswerInfos)
                .FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckErrors("未查询到问题!");
                return null;
            }

            var dto = new QuestionDto()
            {
                Id = entity.Id,
                Title = entity.Title,
                QuestionState = entity.QuestionState,
                AnswerDateTime = entity.AnswerDateTime,
                SubjectCategoryNo = entity.SubjectCategoryNo,
                SubjectCategoryName = entity.SubjectCategory.CategoryName,
                IsFavorite =
                    (await QfRepository.CountAsync(a => a.QuestionNo == entity.Id && a.UserId == AbpSession.UserId)) >
                    0,
                Camp = entity.Camp,
                CampName = entity.Camp.Name,
                ContentInfo = entity.ContentInfo,
                Answers = entity.AnswerInfos.Where(a => a.AnswerNo == null).OrderByDescending(a => a.AnswerState)
                    .ThenByDescending(a => a.Id).Skip(0).Take(IwbConsts.AnswerTakeCount).Select(AnswerDtoMap).ToList(),
                CreatorUserId = entity.CreatorUserId
            };
            return dto;
        }

        /// <summary>
        /// 获取答疑回复
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<AnswerDto>> GetChildAnswer(QueryChildAnswerDto input)
        {
            var query = QaRepository.GetAll();
            if (input.QuestionNo.IsEmpty())
            {
                query = query.Where(a => a.AnswerNo == input.AnswerNo);
            }
            else
            {
                query = query.Where(a => a.QuestionNo == input.QuestionNo);
            }
            query = query.OrderByDescending(a => a.AnswerState).ThenByDescending(a => a.Id);
            int skip = input.Skip ?? 0, take = input.Take ?? IwbConsts.AnswerTakeCount;
            query = query.Skip(skip).Take(take);
            var entities = await query.ToListAsync();
            var list = entities.Select(AnswerDtoMap).ToList();
            return list;
        }

        private AnswerDto AnswerDtoMap(QuestionAnswerInfo input)
        {
            var dto = ObjectMapper.Map<AnswerDto>(input);
            dto.ChildrenCount = QaRepository.Count(a => a.AnswerNo == input.Id);
            var user = QueryUserInfo(input.CreatorUserId);
            dto.ImagePath = user?.AvatarImagePath;
            dto.UserName = user?.UserName;
            dto.RealName = user?.Name;
            return dto;
        }


        private User QueryUserInfo(long? id)
        {
            return CacheManager.GetCache(IwbCacheNames.UserInfoCache).Get($"{id}", () =>
            {
                var user = UserRepository.FirstOrDefault(a => a.Id == id);
                return user;
            });

        }

        /// <summary>
        /// 答疑
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AuditLog("答疑")]
        public async Task<AnswerDto> AddAnswer(AnswerDto input)
        {
            input.Id = $"QA{DateTime.Now:yyyyMMddHHmmssfff}";
            input.AnswerNo = input.AnswerNo.IsEmpty() ? null : input.AnswerNo;
            input.AnswerState = AnswerStateDefinition.New;
            var answer = ObjectMapper.Map<QuestionAnswerInfo>(input);
            answer = await QaRepository.InsertAsync(answer);
            await CurrentUnitOfWork.SaveChangesAsync();
            var dto = AnswerDtoMap(answer);
            return dto;
        }

        /// <summary>
        /// 收藏
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AuditLog("收藏")]
        public async Task Favorite(FavoriteDto input)
        {
            var entity = await GetEntity(input);
            if (entity == null)
            {
                CheckErrors("未查询到问题！");
                return;
            }

            if (input.IsFavorite)
            {
                await QfRepository.InsertAsync(new QuestionFavoriteInfo()
                {
                    QuestionNo = entity.Id,
                    UserId = AbpSession.UserId ?? 0
                });
            }
            else
            {
                await QfRepository.DeleteAsync(a =>
                    a.QuestionNo == entity.Id && a.UserId == AbpSession.UserId);
            }
            //entity.IsFavorite = input.IsFavorite;
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 采纳答疑
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AuditLog("采纳答疑")]
        public async Task SelectAnswer(SelectAnswerDto input)
        {
            var entity = await GetEntity(input);
            if (entity == null)
            {
                CheckErrors("未查询到问题！");
                return;
            }

            var answer = await QaRepository.FirstOrDefaultAsync(a => a.Id == input.AnswerNo);
            if (answer == null)
            {
                CheckErrors("未查询到答疑！");
                return;
            }

            entity.QuestionState = QuestionStateDefinition.Answer;
            entity.AnswerNo = answer.Id;
            entity.AnswerDateTime=DateTime.Now;
            await Repository.UpdateAsync(entity);
            answer.AnswerState = AnswerStateDefinition.Answer;
            await QaRepository.UpdateAsync(answer);
            await CurrentUnitOfWork.SaveChangesAsync();
        }
    }
}