hotline/src/Hotline.Application/Mappers/MapperConfigs.cs

using Hotline.CallCenter.BlackLists;
using Hotline.FlowEngine.Definitions;
using Hotline.FlowEngine.Workflows;
using Hotline.Identity.Roles;
using Hotline.KnowledgeBase;
using Hotline.Orders;
using Hotline.Share.Dtos.CallCenter;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Dtos.Knowledge;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Dtos.Roles;
using Hotline.Share.Dtos.Users;
using Hotline.Users;
using Mapster;

namespace Hotline.Application.Mappers
{
    public class MapperConfigs : IRegister
    {
        public void Register(TypeAdapterConfig config)
        {
            config.ForType<AddBlacklistDto, Blacklist>()
                .Ignore(d => d.Expired)
                .AfterMapping((s, t) => t.InitExpired());

            config.ForType<AddUserDto, User>()
                .Map(d => d.Name, x => x.Name ?? x.UserName);

            config.NewConfig<User, UserDto>()
                .IgnoreIf((s, d) => s.Account == null, d => d.UserName, d => d.Roles)
                .IgnoreIf((s, d) => s.Organization == null, d => d.OrgName)
                .Map(d => d.UserName, x => x.Account.UserName)
                .Map(d => d.OrgName, x => x.Organization.OrgName)
                .Map(d => d.Roles, x => string.Join(',', x.Account.Roles.Select(d => d.DisplayName)))
                .Map(d => d.State, x => x.IsDeleted ? "已删除" : "正常")
                .IgnoreNullValues(true);

            config.NewConfig<Role, RoleDto>()
                .Map(d => d.AccountIds, x => x.Accounts.Select(d => d.Id))
                .Map(d => d.State, x => x.IsDeleted ? "已删除" : "正常");

            #region workflow

            config.ForType<UpdateDefinitionDto, Definition>()
                .Ignore(d => d.Id);

            config.ForType<WorkflowStep, WorkflowStep>()
                .Ignore(d => d.Id)
                .Ignore(d => d.PreviousId)
                .Ignore(d => d.IsMain)
                .Ignore(d => d.Status)
                .Ignore(d => d.ParentId)
                .Ignore(d => d.HandlerIds)
                .Ignore(d => d.Steps)
                .Ignore(d => d.StartCountersignId)
                .Ignore(d => d.CountersignId)
                .Ignore(d => d.IsStartedCountersignComplete)
                ;

            config.ForType<WorkflowStep, WorkflowTrace>()
                .Ignore(d => d.Id)
                .Ignore(d => d.ParentId)
                .Ignore(d => d.Status)
                .Map(d => d.StepId, s => s.Id);

            config.ForType<WorkflowSupplement, WorkflowSupplementDto>()
                .IgnoreIf((s, d) => s.Creator == null, d => d.Creator);

            config.ForType<Workflow, WorkflowDto>()
                .IgnoreIf((s, d) => s.Assigns == null || !s.Assigns.Any(), d => d.AssignOrgs)
                .Map(d => d.AssignOrgs, s => string.Join(',', s.Assigns.Select(d => d.OrgName)))
                ;

            config.ForType<BasicWorkflowDto, WorkflowStep>()
                .Map(d => d.NextHandlers, s => s.NextHandlers)
                .Map(d => d.NextMainHandler, s => s.NextMainHandler)
                .Map(d => d.NextStepCode, s => s.NextStepCode)
                .Map(d => d.AcceptSms, s => s.AcceptSms)
                .Map(d => d.Opinion, s => s.Opinion)
                .Map(d => d.Additions, s => s.Additions)
                .IgnoreNonMapped(true)
                ;

            #endregion

            #region Knowledge
            config.NewConfig<KnowledgeApply, KnowledgeApplyHandlePageDto>()
                 .Map(d => d.CreationName, x => x.User.Name)
                   .Map(d => d.CreationOrgName, x => x.SystemOrganize.OrgName);

            config.NewConfig<Hotline.KnowledgeBase.Knowledge, KnowledgeDataDto>()
              .Map(d => d.CreationName, x => x.User.Name)
                .Map(d => d.KnowledgeTypeName, x => x.KnowledgeType.SpliceName)
                 .Map(d => d.HotspotName, x => x.HotSpotType.HotSpotFullName);

            config.NewConfig<Hotline.KnowledgeBase.Knowledge, KnowledgeApprovalDataDto>()
            .Map(d => d.CreationName, x => x.User.Name)
              .Map(d => d.KnowledgeTypeName, x => x.KnowledgeType.SpliceName)
                 .Map(d => d.CreateBMName, x => x.SystemOrganize.OrgName);

            config.NewConfig<KnowledgeWorkFlow, KnowledgeApprovalDataDto>()
                .Map(d => d.CreationName, x => x.Knowledge.User.Name)
                .Map(d => d.KnowledgeTypeName, x => x.Knowledge.KnowledgeType.SpliceName)
                .Map(d => d.CreateBMName, x => x.Knowledge.SystemOrganize.OrgName)
                .Map(d => d.Id, x => x.Knowledge.Id)
                .Map(d => d.Title, x => x.Knowledge.Title)
                .Map(d => d.PageView, x => x.Knowledge.PageView)
                .Map(d => d.Status, x => x.Knowledge.Status)
                .Map(d => d.WorkflowModuleStatus, x => x.WorkflowModuleStatus)
                .Map(d => d.Time, x => x.Workflow.CurrentStepTime);

            config.NewConfig<KnowledgeWorkFlow, KnowledgeDeleteApplyDataDto>()
                 .Map(d => d.Id, x => x.Knowledge.Id)
                  .Map(d => d.Title, x => x.Knowledge.Title)
               .Map(d => d.KnowledgeTypeName, x => x.Knowledge.KnowledgeType.SpliceName)
               .Map(d => d.HotspotName, x => x.Knowledge.HotSpotType.HotSpotFullName)
               .Map(d => d.CreationName, x => x.Knowledge.User.Name)
               .Map(d => d.CreationBMName, x => x.Knowledge.SystemOrganize.OrgName)
               .Map(d => d.PageView, x => x.Knowledge.PageView)
               .Map(d => d.Status, x => x.Knowledge.Status)
               .Map(d => d.WorkFlowApplyStatus, x => x.WorkflowModuleStatus);

            #endregion

            #region order

            config.ForType<Order, OrderDto>()
                .IgnoreIf((s, d) => s.OrderComplain == null, d => d.OrderComplain)
                .IgnoreIf((s, d) => s.OrderReport == null, d => d.OrderReport)
                .IgnoreIf((s, d) => s.Workflow == null, d => d.Workflow)
                .IgnoreIf((s, d) => s.Employee == null, d => d.EmployeeName, d => d.EmployeeStaffNo)
                .Ignore(d => d.Workflow.Definition)
                .Ignore(d => d.Workflow.StepBoxes)
                .Ignore(d => d.Workflow.Traces)
                ;

            config.ForType<AddOrderDto, Order>()
                .IgnoreIf((s, d) => s.OrderComplain == null, d => d.OrderComplain)
                .IgnoreIf((s, d) => s.OrderReport == null, d => d.OrderReport);

            config.ForType<UpdateOrderDto, Order>()
                .Inherits<AddOrderDto, Order>();

            #endregion
        }
    }
}