micro-document/internel/logic/members.go

package logic

import (
	"errors"
	"micro-document/api/members"
	"micro-document/internel/dao"
	"micro-document/internel/model"

	"github.com/google/uuid"
	"github.com/samber/lo"
)

type membersLogic struct{}

var MembersLogic = new(membersLogic)

func (membersLogic) AddMember(req *members.AddMemberReq) (result *members.AddMemberResp, err error) {
	result = &members.AddMemberResp{}
	if req.Uuid == "" {
		req.Uuid = uuid.New().String()
	}
	if req.Name == "" {
		return nil, errors.New("姓名不能为空")
	}
	err = dao.MembersDao.AddMember(req)
	if err != nil {
		return nil, err
	}
	result.Msg = "新增成员成功"
	return nil, nil
}

func (membersLogic) EditMember(req *members.EditMemberReq) (result *members.EditMemberResp, err error) {
	result = &members.EditMemberResp{}
	err = dao.MembersDao.EditMember(req)
	if err != nil {
		return nil, err
	}
	result.Msg = "编辑成员成功"
	return nil, nil
}

func (membersLogic) DeleteMember(req *members.DeleteMemberReq) (result *members.DeleteMemberResp, err error) {
	result = &members.DeleteMemberResp{}
	err = dao.MembersDao.DeleteMember(req)
	if err != nil {
		return nil, err
	}
	result.Msg = "删除成员成功"
	return nil, nil
}

func (membersLogic) GetMemberList(req *members.GetMemberListReq) (result *members.GetMemberListResp, err error) {
	result = &members.GetMemberListResp{
		Page:     req.Page,
		PageSize: req.PageSize,
	}
	data, total, err := dao.MembersDao.GetMemberList(req)
	if err != nil {
		return nil, errors.New("查询成员列表失败")
	}
	//查询获取成员管理，董事会，委员会信息
	result.Total = int32(total)

	result.Data = make([]*members.Member, len(data))
	for i, member := range data {
		result.Data[i] = &members.Member{
			Uuid:         member.Uuid,
			Name:         member.Name,
			Brief:        member.Brief,
			Introduction: member.Introduction,
			Sort:         member.Sort,
			UpdatedAt:    member.UpdatedAt.Format("2006-01-02 15:04:05"),
			Operator:     member.Operator,
		}
	}

	if len(result.Data) > 0 {
		// 收集所有UUID
		uuids := make([]string, len(result.Data))
		for i, member := range result.Data {
			uuids[i] = member.Uuid
		}

		// 批量查询所有关联数据
		managementMap, err := dao.MembersDao.GetManagementByUuids(uuids)
		if err != nil {
			return nil, errors.New("批量查询成员管理失败")
		}

		boardOfDirectorsMap, err := dao.MembersDao.GetBoardOfDirectorsByUuids(uuids)
		if err != nil {
			return nil, errors.New("批量查询董事会失败")
		}

		committeeAppointmentsMap, err := dao.MembersDao.GetCommitteeAppointmentsByUuids(uuids)
		if err != nil {
			return nil, errors.New("批量查询委员会失败")
		}

		// 批量赋值
		for _, member := range result.Data {
			if management, exists := managementMap[member.Uuid]; exists {
				member.Management = &members.Management{
					Name:         management.Name,
					Image:        management.Image,
					Brief:        management.Brief,
					Introduction: management.Introduction,
					Status:       management.Status,
					IsSetting:    management.IsSetting,
				}
			}

			if boardOfDirectors, exists := boardOfDirectorsMap[member.Uuid]; exists {
				member.BoardOfDirectors = &members.BoardOfDirectors{
					Name:         boardOfDirectors.Name,
					Status:       boardOfDirectors.Status,
					Brief:        boardOfDirectors.Brief,
					Introduction: boardOfDirectors.Introduction,
					IsSetting:    boardOfDirectors.IsSetting,
				}
			}

			if committeeAppointments, exists := committeeAppointmentsMap[member.Uuid]; exists {
				member.CommitteeAppointments = &members.CommitteeAppointments{
					Name:                  committeeAppointments.Name,
					Status:                committeeAppointments.Status,
					AuditCommittee:        committeeAppointments.AuditCommittee,
					CompensationCommittee: committeeAppointments.CompensationCommittee,
					NominatingCommittee:   committeeAppointments.NominatingCommittee,
					IsSetting:             committeeAppointments.IsSetting,
				}
			}
		}
	}
	return result, nil
}

// 编辑成员管理
func (membersLogic) EditManagement(req *members.EditManagementReq) (result *members.EditManagementResp, err error) {
	result = &members.EditManagementResp{}
	err = dao.MembersDao.EditManagement(req)
	if err != nil {
		return nil, err
	}
	result.Msg = "编辑成员管理成功"
	return result, nil
}

// 展示成员管理列表
func (membersLogic) DisplayManagement(req *members.DisplayManagementReq) (result *members.DisplayManagementResp, err error) {
	result = &members.DisplayManagementResp{}
	data, err := dao.MembersDao.GetDisplayManagementList()
	if err != nil {
		return nil, err
	}
	result.Item = lo.Map(data, func(m model.Management, i int) *members.DisplayManagementItem {
		return &members.DisplayManagementItem{
			Name:         m.Name,
			Image:        m.Image,
			Brief:        m.Brief,
			Introduction: m.Introduction,
		}
	})
	return result, nil
}

// 编辑董事会
func (membersLogic) EditBoardOfDirectors(req *members.EditBoardOfDirectorsReq) (result *members.EditBoardOfDirectorsResp, err error) {
	result = &members.EditBoardOfDirectorsResp{}
	err = dao.MembersDao.EditBoardOfDirectors(req)
	if err != nil {
		return nil, err
	}
	result.Msg = "编辑董事会成功"
	return result, nil
}

// 展示董事会列表
func (membersLogic) DisplayBoardOfDirectors(req *members.DisplayBoardOfDirectorsReq) (result *members.DisplayBoardOfDirectorsResp, err error) {
	result = &members.DisplayBoardOfDirectorsResp{}
	data, err := dao.MembersDao.GetDisplayBoardOfDirectorsList()
	if err != nil {
		return nil, err
	}
	result.Item = lo.Map(data, func(m model.BoardOfDirectors, i int) *members.DisplayBoardOfDirectorItem {
		return &members.DisplayBoardOfDirectorItem{
			Name:         m.Name,
			Brief:        m.Brief,
			Introduction: m.Introduction,
		}
	})
	return result, nil
}

// 编辑委员会
func (membersLogic) EditCommitteeAppointments(req *members.EditCommitteeAppointmentsReq) (result *members.EditCommitteeAppointmentsResp, err error) {
	result = &members.EditCommitteeAppointmentsResp{}
	err = dao.MembersDao.EditCommitteeAppointments(req)
	if err != nil {
		return nil, err
	}
	result.Msg = "编辑委员会成功"
	return result, nil
}

// 展示委员会列表
func (membersLogic) DisplayCommitteeAppointments(req *members.DisplayCommitteeAppointmentsReq) (result *members.DisplayCommitteeAppointmentsResp, err error) {
	result = &members.DisplayCommitteeAppointmentsResp{}
	data, err := dao.MembersDao.GetDisplayCommitteeAppointmentsList()
	if err != nil {
		return nil, err
	}
	result.Item = lo.Map(data, func(m model.CommitteeAppointments, i int) *members.DisplayCommitteeAppointmentsItem {
		return &members.DisplayCommitteeAppointmentsItem{
			Name:                  m.Name,
			AuditCommittee:        m.AuditCommittee,
			CompensationCommittee: m.CompensationCommittee,
			NominatingCommittee:   m.NominatingCommittee,
		}
	})
	return result, nil
}