fix:bug修复

zhengyuxuan

2025-04-02 dbf044662b9a75e5b42f8f76c65faaf89c95bb21

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
using LifePayment.Application.Contracts;
using LifePayment.Domain.Models;
using LifePayment.Domain.Shared;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using ZeroD.Util;
 
namespace LifePayment.Application
{
    public class OperateHistoryService : ApplicationService, IOperateHistoryService
    {
        private readonly IRepository<OperateHistory, Guid> _operateHistory;
 
        public OperateHistoryService(
               IRepository<OperateHistory, Guid> operateHistory)
        {
            _operateHistory = operateHistory;
        }
 
        public async Task<PageOutput<OperateHistoryDto>> GetOperateHistoryByRelationId(GetOperateHistoryInput input)
        {
            var query = _operateHistory.Where(r => r.RelationId == input.RelationId)
                                       .WhereIf(input.OperateName.IsNotNullOrEmpty(), r => r.OperateName == input.OperateName)
                                       .Select(r => new OperateHistoryDto
                                       {
                                           OperateName = r.OperateName,
                                           RelationId = r.RelationId,
                                           CreationTime = r.CreationTime,
                                           CreatorName = r.CreatorName,
                                           OperateContent = r.OperateContent,
                                           TableType = r.TableType
                                       });
            var result = await query.GetPageResult(input.PageModel);
 
            return result;
        }
 
        public async Task<PageOutput<OperateHistoryDto>> GetOperateHistoryByType(QueryOperateHistoryByTypeInput input)
        {
            var query = _operateHistory.AsQueryable();
            switch (input.OperateHistoryType)
            {
                case OperateHistoryTypeEnum.AccountManage:
                    query = query.Where(x => x.UserId == input.TypeId
                                          && LifePaymentConstant.LogsSpecies.AccountManageOperateNameList.Contains(x.OperateName));
                    break;
                case OperateHistoryTypeEnum.LifePayChannles:
                    query = query.Where(x => x.RelationId == input.TypeId);
 
                    break;
                default:
                    query = query.Where(x => x.RelationId == input.TypeId);
 
                    break;
            }
 
            var result = await query.Select(r =>
                                            new OperateHistoryDto
                                            {
                                                OperateName = r.OperateName,
                                                RelationId = r.RelationId,
                                                CreationTime = r.CreationTime,
                                                CreatorName = r.CreatorName,
                                                OperateContent = r.OperateContent,
                                                TableType = r.TableType
                                            })
                                    .GetPageResult(input.PageModel);
            return result;
        }
    }
}