feat:开发

sunpengfei

2025-08-22 a2615c138637b55691a78801c069605aaa56eecc

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
using FlexJobApi.Core;
using Furion.DatabaseAccessor;
using Furion.DataEncryption;
using Furion.FriendlyException;
using Mapster;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace FlexJobApi.UserServer.Application
{
    /// <summary>
    /// 企业命令处理器
    /// </summary>
    public class EnterpriseCommandHandler(
            IMediator mediator,
            IRepository<Enterprise> rep,
            IRepository<User> repUser
        ) :
        IRequestHandler<SaveEnterpriseCommand, Guid>,
        IRequestHandler<SetEnterpriseElectronSignSettingCommand, Guid>,
        IRequestHandler<SetEnterpriseSmsSettingCommand, Guid>
 
    {
        private readonly IMediator mediator = mediator;
        private readonly IRepository<Enterprise> rep = rep;
        private readonly IRepository<User> repUser = repUser;
 
        /// <summary>
        /// 保存企业
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<Guid> Handle(SaveEnterpriseCommand request, CancellationToken cancellationToken)
        {
            var entity = await rep.AsQueryable()
                .FirstOrDefaultAsync(it => it.SocietyCreditCode == request.SocietyCreditCode);
            if (entity == null)
            {
                entity = new Enterprise();
                request.Adapt(entity);
                await rep.InsertAsync(entity);
            }
            else
            {
                request.Adapt(entity);
                await rep.UpdateAsync(entity);
            }
 
            var user = await repUser.AsQueryable()
                .FirstOrDefaultAsync(it =>
                    it.Type == EnumUserType.Enterprise
                    && it.UserName == request.UserName);
            if (user == null)
            {
                if (request.Password.IsNull()) throw Oops.Oh(EnumErrorCodeType.s400, "请填写密码");
                user = new User
                {
                    EnterpriseId = entity.Id,
                    Type = EnumUserType.Enterprise,
                    Name = request.Contacts,
                    PhoneNumber = request.ContactPhoneNumber,
                    UserName = request.UserName,
                    Password = request.Password.EncryptPassword(),
                    Level = 100,
                    Status = EnumUserStatus.Normal,
                };
                await repUser.InsertAsync(user);
            }
            else
            {
                if (user.EnterpriseId != entity.Id) throw Oops.Oh(EnumErrorCodeType.s405, "账号");
                user.Name = request.Contacts;
                user.PhoneNumber = request.ContactPhoneNumber;
                if (request.Password.IsNotNull())
                {
                    user.Password = request.Password.EncryptPassword();
                }
                await repUser.UpdateAsync(user);
            }
 
            return entity.Id;
        }
 
        /// <summary>
        /// 设置企业电子签配置
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<Guid> Handle(SetEnterpriseElectronSignSettingCommand request, CancellationToken cancellationToken)
        {
            var entity = await rep.AsQueryable()
                .Include(it => it.ElectronSignSettings)
                .FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken);
            if (entity == null) throw Oops.Oh(EnumErrorCodeType.s404, "企业");
 
            await mediator.Send(new CheckElectronSignAccessEnabledsCommand
            {
                Accesses = request.ElectronSignAccesses
            }, cancellationToken);
 
            entity.ElectronSignSettings = request.ElectronSignAccesses
                .Select(it =>
                {
                    var setting = entity.ElectronSignSettings.FirstOrDefault(s => s.ElectronSignAccess == it);
                    if (setting == null)
                    {
                        setting = new EnterpriseElectronSignSetting
                        {
                            ElectronSignAccess = it
                        };
                    }
                    return setting;
                })
                .ToList();
            await rep.UpdateAsync(entity);
            return entity.Id;
        }
 
        /// <summary>
        /// 设置企业短信配置
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<Guid> Handle(SetEnterpriseSmsSettingCommand request, CancellationToken cancellationToken)
        {
            var entity = await rep.AsQueryable().FirstOrDefaultAsync(it => it.Id == request.Id, cancellationToken);
            if (entity == null) throw Oops.Oh(EnumErrorCodeType.s404, "企业");
            request.Adapt(entity);
            await rep.UpdateAsync(entity);
            return entity.Id;
        }
    }
}