package com.vci.ubcs.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springblade.core.log.exception.ServiceException;
import com.vci.ubcs.system.entity.Combination;
import com.vci.ubcs.system.mapper.CombinationMapper;
import com.vci.ubcs.system.service.ICombinationService;
import org.springblade.core.cache.utils.CacheUtil;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tool.utils.Func;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;

import static org.springblade.core.cache.constant.CacheConstant.SYS_CACHE;

/**
 * 密码组合方式表(PlSysCombination)表服务实现类
 *
 * @author makejava
 * @since 2023-03-20 15:23:22
 */
@Service
@Validated
//@AllArgsConstructor
public class CombinationServiceImpl extends ServiceImpl<CombinationMapper,Combination> implements ICombinationService {

	@Resource
	private CombinationMapper combinationMapper;

	/**
	 * 通过ID查询单条数据
	 *
	 * @param id 主键
	 * @return 实例对象
	 */
	@Override
	public Combination queryById(Long id) {
		Combination combination = this.getOne(Wrappers.<Combination>query().lambda().eq(Combination::getId, id));
		return combination;
	}

	/**
	 * 分页查询
	 *
	 * @param combination 筛选条件
	 * @param page      分页对象
	 * @return 查询结果
	 */
	@Override
	public IPage<Combination> selectCombinationPage(Combination combination, IPage<Combination> page) {
		IPage<Combination> combinationIPage = combinationMapper.selectPage(page, Condition.getQueryWrapper(combination));
		// page.setRecords(combinationMapper.selectCombinationPage(page,combination))
		return combinationIPage;
	}

	/**
	 * 新增数据和修改数据
	 *
	 * @param combination 实例对象
	 * @return 实例对象
	 */
	@Override
	public boolean submit(Combination combination) {
		//判断是否携带id
		if(Func.isEmpty(combination.getId())){
			//新增
			Combination dbcombination = this.getOne(Wrappers.<Combination>query().lambda().eq(Combination::getName, combination.getName()));
			//如果数据库中存在这条组合名称的记录直接返回
			if(!Func.isEmpty(dbcombination)){
				throw new ServiceException("组合名称已存在!");
			}
			if(Func.isEmpty(combination.getCreateTime())){
				combination.setCreateTime(new Date());
			}
			if(Func.isEmpty(combination.getUpdateTime())){
				combination.setUpdateTime(new Date());
			}
			boolean temp = saveOrUpdate(combination);
			return temp;
		}else {
			if(Func.isEmpty(combination.getUpdateTime())){
				combination.setUpdateTime(new Date());
			}
			CacheUtil.clear(SYS_CACHE, Boolean.FALSE);
			return saveOrUpdate(combination);
		}
	}

	/**
	 * 通过主键删除数据
	 *
	 * @param ids 主键
	 * @return 是否成功
	 */
	@Override
	public boolean deleteByIds(List<String> ids) {
		boolean tenantTemp = this.removeBatchByIds(ids);
		return tenantTemp;
	}

	/**
	 * 查询密码组合id：组合名，键值对
	 *
	 * @return 键值对
	 */
	@Override
	public List<Map<String, Object>> selectMaps() {
		List<Map<String, Object>> maps = listMaps(
			new QueryWrapper<Combination>().lambda().select(Combination::getId, Combination::getName)
		);
		return maps;
	}

	@Override
	public String getRegex(List<String> combinationIds) {
		return combinationMapper.queryRegex(combinationIds);
	}

	@Override
	public List<String> getRegexList(List<String> combinationIds) {
		return combinationMapper.queryRegexList(combinationIds);
	}

}