优化

MrShi

2 天以前 4eac422e52a4d28fb651b75d0f054697c7a2c0fa

 server/dmmall_service/src/main/java/com/doumee/service/business/impl/UserActionServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,157 @@
package com.doumee.service.business.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.UserActionMapper;
import com.doumee.dao.business.model.Member;
import com.doumee.dao.business.model.UserAction;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.service.business.UserActionService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * äººå‘˜æ“ä½œè®°å½•æ—¥å¿—Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2023/12/14 13:57
 */
@Service
public class UserActionServiceImpl implements UserActionService {

    @Autowired
    private UserActionMapper userActionMapper;


    @Override
    public Integer create(UserAction userAction) {
        userActionMapper.insert(userAction);
        return userAction.getId();
    }

    @Override
    public void deleteById(Integer id) {
        userActionMapper.deleteById(id);
    }

    @Override
    public void delete(UserAction userAction) {
        UpdateWrapper<UserAction> deleteWrapper = new UpdateWrapper<>(userAction);
        userActionMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        userActionMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(UserAction userAction) {
        userActionMapper.updateById(userAction);
    }

    @Override
    public void updateByIdInBatch(List<UserAction> userActions) {
        if (CollectionUtils.isEmpty(userActions)) {
            return;
        }
        for (UserAction userAction: userActions) {
            this.updateById(userAction);
        }
    }
    public static void saveUserActionBiz(LoginUserInfo user,
                                         Integer bizId,
                                         Constants.UserActionType type,
                                         UserActionMapper userActionMapper,
                                         Date date,
                                         String[] params,
                                         String modelInfo,
                                         String before,
                                         String after) {
        String info = type.getInfo();
        if(params!=null){
            for (int i = 0; i < params.length; i++) {
                info = info.replace("${param"+(i+1)+"}",params[i]);
            }
        }
        UserAction userAction=new UserAction();
        userAction.setIsdeleted(Constants.ZERO);
        userAction.setCreateDate(date);
        userAction.setCreator(user.getId());
        userAction.setBeforeStatus(Constants.ZERO);
        userAction.setType(type.getKey());
        userAction.setContent(modelInfo);
        userAction.setRemark(info);
        userAction.setBeforeInfo(before);
        userAction.setAfterInfo(after);
        userAction.setMemberId(bizId+"");
        userActionMapper.insert(userAction);
    }
    @Override
    public UserAction findById(Integer id) {
        return userActionMapper.selectById(id);
    }

    @Override
    public UserAction findOne(UserAction userAction) {
        QueryWrapper<UserAction> wrapper = new QueryWrapper<>(userAction);
        return userActionMapper.selectOne(wrapper);
    }
    @Override
    public List<UserAction> findList(UserAction userAction) {
        QueryWrapper<UserAction> wrapper = new QueryWrapper<>(userAction);
        return userActionMapper.selectList(wrapper);
    }
    @Override
    public PageData<UserAction> findPage(PageWrap<UserAction> pageWrap) {
        IPage<UserAction> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<UserAction> queryWrapper = new MPJLambdaWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        UserAction queryModel =  pageWrap.getModel();
        queryWrapper.selectAll(UserAction.class)
//                .leftJoin(Member.class,Member::getId,UserAction::getMemberId)
                .leftJoin(SystemUser.class,SystemUser::getId,UserAction::getCreator)
                .selectAs(SystemUser::getRealname,UserAction::getCreateName)
//                .selectAs(Member::getName,UserAction::getMemberName)
//                .selectAs(Member::getPhone,UserAction::getMobile)
                .like(StringUtils.isNotBlank(queryModel.getCreateName()),SystemUser::getRealname,queryModel.getCreateName())
                .like(StringUtils.isNotBlank(queryModel.getMemberName()),Member::getName,queryModel.getMemberName())
                .like(StringUtils.isNotBlank(queryModel.getMobile()),Member::getPhone,queryModel.getMobile())
                .like(StringUtils.isNotBlank(queryModel.getRemark()),Member::getPhone,queryModel.getRemark())
                .eq(!Objects.isNull(queryModel.getMemberType()),Member::getType,queryModel.getMemberType())
                .eq(!Objects.isNull(queryModel.getBeforeStatus()),UserAction::getBeforeStatus,queryModel.getBeforeStatus())
                .eq(!Objects.isNull(queryModel.getMemberId()),UserAction::getMemberId,queryModel.getMemberId())
                .eq(!Objects.isNull(queryModel.getType()),UserAction::getType,queryModel.getType())
                .eq(!Objects.isNull(queryModel.getId()),UserAction::getId,queryModel.getId())
                .orderByDesc(UserAction::getCreateDate);
        IPage<UserAction> result =  userActionMapper.selectJoinPage(page,UserAction.class,queryWrapper);
        if(result!=null &&result.getRecords()!=null){
            for(UserAction model :result.getRecords()){
                model.setTypeName(Constants.UserActionType.getName(model.getType()));
            }
        }
        return PageData.from(result);
    }

    @Override
    public long count(UserAction userAction) {
        QueryWrapper<UserAction> wrapper = new QueryWrapper<>(userAction);
        return userActionMapper.selectCount(wrapper);
    }
}