num-mall / pretty-num-server

package com.uccc.admin.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.uccc.admin.config.RabbitMQConfig;
import com.uccc.admin.domain.Permission;
import com.uccc.admin.exception.ApiException;
import com.uccc.admin.mapper.UserMapper;
import com.uccc.admin.service.PermissionService;
import com.uccc.admin.service.RoleService;
import com.uccc.admin.service.UserService;
import com.uccc.pretty.common.*;
import com.uccc.pretty.constants.ErrorCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;


/**
 * Created by bert on 2018/12/4.
 */
@Service
public class UserServiceImpl implements UserService {

    final private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private RoleService roleService;

    @Autowired
    private PermissionService permissionService;

    @Override
    public void sendSystemLogToRabbitMq(String systemLog) throws NullPointerException{
        try {
           this.rabbitTemplate.convertAndSend(RabbitMQConfig.PRETTY_ADMIN, systemLog);
        }catch (AmqpException e) {
           logger.error("Send Rabbitmq message err", e.getMessage());
        }
    }

    @Override
    public User getUserByCondition(User user) {
        return userMapper.selectUserByCondition(user);
    }

    @Override
    public boolean updateUser(User user) {
        if (user.getRoleIds() != null) {
            if (user.getRoleIds().length > 0) {
                int[] roleIds = user.getRoleIds();
                AtomicBoolean delRes = new AtomicBoolean(true);
                int roleDeleteRes = roleService.deleteRoleByUser(user);
                if (!(roleDeleteRes > 0)) {
                    delRes.set(false);
                }
                Arrays.stream(roleIds).forEach(d->{
                    int roleCreateRes = roleService.createUserRoleByUserId(user.getId(), d);
                    if (!(roleCreateRes > 0)) {
                        delRes.set(false);
                    }
                });
                if (!delRes.get()) {
                    return false;
                }
            }
        }
        int res = userMapper.updateUser(user);
        if (res > 0) {
            return true;
        }else {
            return false;
        }
    }

    @Override
    public List<UserEntity> getUserListByCondition(User user) {
        List<User> users = userMapper.selectUserListByCondition(user);
        logger.info("user len:{}", users.size());
        List<UserEntity> userEntities = new ArrayList<>();
        users.forEach(d->{
            List<Permission> permissionList = permissionService.getPermissionByUserId(d.getId());
            if (permissionList.size() == 0) {
                throw new ApiException(ErrorCode.USER_PERMISSION_NOT_FOUND);
            }else {
                JSONArray jsonArray = permissionService.formatPermissions(permissionList);
                d.setPermission(jsonArray);
            }
            List<Role> roles = roleService.getRoleByUserId(d.getId());
//            if (!(roles.size() > 0)) throw new ApiException(ErrorCode.SERVER_ERROR);
            d.setRoleNames(roles);
            if (d.getStoreId() != null) {
                Store store = checkStoreByMid(Long.valueOf(d.getStoreId()));
                d.setStore(store);
            }
            String jsonString = JSONObject.toJSONString(d);
            UserEntity userEntity = JSONObject.parseObject(jsonString,UserEntity.class);
            userEntities.add(userEntity);
        });
        return userEntities;
    }

    @Override
    public int checkAccountRepeat(String account) {
        return userMapper.checkAccountRepeat(account);
    }

    @Override
    public boolean createUser(User user, int[] roles) {
        int result = userMapper.createUser(user);
        User cUser = new User();
        if (result == 1) {
            cUser.setAccount(user.getAccount());
            cUser = getUserByCondition(cUser);
        }else {
            return false;
        }
        logger.info("create user_id:{}", cUser.getId());
        AtomicBoolean roleResult = new AtomicBoolean(true);
        User finalCUser = cUser;
        Arrays.stream(roles).forEach(d->{
            long roleResultTemp = roleService.createUserRoleByUserId(finalCUser.getId(), d);
            if (!(roleResultTemp > 0)) {
                roleResult.set(false);
            }
        });
        if (roleResult.get()) {
            return true;
        }else {
            return false;
        }

    }

    @Override
    public boolean deleteUser(User user) {
        //pretend to delete
        int deleteUserCount = userMapper.deleteUserByUserId(user);
        if (!(deleteUserCount > 0)) {
            return false;
        }
        return true;
    }

    @Override
    public int getUserListCountByCondition(User user) {
        return userMapper.selectUserListCountByCondition(user);

    }

    @Override
    public Store checkStoreByMid(Long mid) {
        return userMapper.checkStoreByMid(mid);
    }

    @Override
    public int createStore(Store store) {
        return userMapper.createStore(store);
    }

    @Override
    public int checkStoreNameRepeat(String name) {
        return userMapper.checkStoreNameRepeat(name);
    }

    @Override
    public Store findStoreByName(String name) {
        return userMapper.SelectStoreByName(name);
    }

    @Override
    public int updateStore(Store store) {
        return userMapper.updateStore(store);
    }

    @Override
    public List<StoreEntity> getStoreByCondition(Store store, Integer limit, Integer offset) {
        return userMapper.selectStoreByCondition(store, limit, offset);
    }

    @Override
    public int getStoreCountByCondition(Store store) {
        return userMapper.selectStoreCountByCondition(store);
    }

}