feat:开发

sunpengfei

2025-08-18 4b574fd74eece20f4e64b48c39c5aa6ad70b0d0f

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
using FlexJobApi.Core;
using Furion.DatabaseAccessor;
using Furion.FriendlyException;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace FlexJobApi.FlexJobServer.Application
{
    /// <summary>
    /// 任务人员命令处理器
    /// </summary>
    public class TaskUserCommandHandler(
            IRepository<TaskInfoUser> rep,
            IRepository<TaskUserCollect> repTaskUserCollect
        ) :
        IRequestHandler<CollectTaskCommand, int>,
        IRequestHandler<ClearTaskCollectCommand, int>,
        IRequestHandler<SetTaskUserHireCommand, Guid>,
        IRequestHandler<SetTaskUserArrangeCommand, Guid>
    {
        private readonly IRepository<TaskInfoUser> rep = rep;
        private readonly IRepository<TaskUserCollect> repTaskUserCollect = repTaskUserCollect;
 
        /// <summary>
        /// 收藏任务
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<int> Handle(CollectTaskCommand request, CancellationToken cancellationToken)
        {
            var logier = JwtUtils.GetCurrentLogier();
            var collects = await repTaskUserCollect.AsQueryable().AsNoTracking()
                .Where(it => request.Ids.Contains(it.TaskInfoId) && it.UserId == logier.Id)
                .ToListAsync(cancellationToken);
            if (request.IsCollect)
            {
                var addIds = request.Ids.Where(it => !collects.Any(c => c.TaskInfoId == it)).ToList();
                foreach (var addId in addIds)
                {
                    var entity = new TaskUserCollect
                    {
                        TaskInfoId = addId,
                        UserId = logier.Id
                    };
                    await repTaskUserCollect.InsertAsync(entity);
                }
                return addIds.Count;
            }
            else
            {
                await repTaskUserCollect.DeleteAsync(collects);
                return collects.Count;
            }
        }
 
        /// <summary>
        /// 清空已停止的任务收藏
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<int> Handle(ClearTaskCollectCommand request, CancellationToken cancellationToken)
        {
            var logier = JwtUtils.GetCurrentLogier();
            var entities = await repTaskUserCollect.AsQueryable()
                .Where(it => it.TaskInfo.ReleaseStatus == EnumTaskReleaseStatus.Stopped && it.UserId == logier.Id)
                .ToListAsync(cancellationToken);
            if (entities.IsNotNull())
            {
                foreach (var entity in entities)
                {
                    await repTaskUserCollect.DeleteAsync(entity);
                }
            }
            return entities.Count;
        }
 
        /// <summary>
        /// 任务录用
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<Guid> Handle(SetTaskUserHireCommand request, CancellationToken cancellationToken)
        {
            var logier = JwtUtils.GetCurrentLogier();
            var entity = await rep.AsQueryable()
                .Include(it => it.EnterpriseEmployee)
                .Where(it =>
                    it.TaskInfo.EnterpriseId == logier.EnterpriseId
                    && it.Id == request.Id)
                .FirstOrDefaultAsync(cancellationToken);
            if (entity == null) throw Oops.Oh(EnumErrorCodeType.s404, "报名信息");
            if (entity.HireStatus == EnumTaskUserHireStatus.Pass) throw Oops.Oh(EnumErrorCodeType.s510, "灵工已录用");
            entity.HireStatus = request.HireStatus;
            if (entity.HireStatus == EnumTaskUserHireStatus.Pass)
            {
                entity.EnterpriseEmployee.UserSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                entity.EnterpriseEmployee.UserSignContractTime = DateTime.Now;
                entity.EnterpriseEmployee.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                entity.EnterpriseEmployee.EnterpriseSignContractTime = DateTime.Now;
 
                entity.HireTime = DateTime.Now;
                entity.ArrangeStatus = EnumTaskUserArrangeStatus.Wait;
            }
            await rep.UpdateAsync(entity);
            return entity.Id;
        }
 
        /// <summary>
        /// 任务安排
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<Guid> Handle(SetTaskUserArrangeCommand request, CancellationToken cancellationToken)
        {
            var logier = JwtUtils.GetCurrentLogier();
            var entity = await rep.AsQueryable()
                .Include(it => it.TaskInfo)
                .Include(it => it.EnterpriseEmployee)
                .Where(it =>
                    it.TaskInfo.EnterpriseId == logier.EnterpriseId
                    && it.Id == request.Id)
                .FirstOrDefaultAsync(cancellationToken);
            if (entity == null) throw Oops.Oh(EnumErrorCodeType.s404, "报名信息");
            if (entity.ArrangeStatus == EnumTaskUserArrangeStatus.Complete) throw Oops.Oh(EnumErrorCodeType.s510, "灵工已安排");
            entity.ArrangeStatus = request.ArrangeStatus;
            if (entity.ArrangeStatus == EnumTaskUserArrangeStatus.Complete)
            {
                entity.ArrangeTime = DateTime.Now;
                entity.CheckReceiveStatus = EnumTaskCheckReceiveStatus.WaitSubmit;
                entity.TaskInfo.Status = EnumTaskStatus.Complete;
                entity.TaskInfo.CheckReceiveStatus = EnumTaskCheckReceiveStatus.WaitSubmit;
            }
            await rep.UpdateAsync(entity);
            return entity.Id;
        }
    }
}