meidu2021/daju/target/classes/cn/com/lzt/useractiviti/service/impl/UserActivitiServiceImpl.java

package cn.com.lzt.useractiviti.service.impl;
import cn.com.lzt.arrangedutyoperate.entity.ArrangeDutyOperateEntity;
import cn.com.lzt.cost.pettycashaccount.service.TBCostPettyCashAccountServiceI;
import cn.com.lzt.dingding.service.DingdingService;
import cn.com.lzt.duties.entity.DutiesEntity;
import cn.com.lzt.leave.dto.LeaveDto;
import cn.com.lzt.personnelbasearchivesmanage.entity.PersonnelBaseArchivesManageEntity;
import cn.com.lzt.personnelbasearchivesmanage.service.PersonnelBaseArchivesManageServiceI;
import cn.com.lzt.projarrangedetail.entity.ProjarrangeDetailEntity;
import cn.com.lzt.socialsecuritystrategy.entity.SocialSecurityStrategyEntity;
import cn.com.lzt.useractiviti.data.service.UseractivitiDataServiceI;
import cn.com.lzt.useractiviti.entity.TBusActivitiUserPersonnelEntity;
import cn.com.lzt.useractiviti.entity.TBusUserBlackListEntity;
import cn.com.lzt.useractiviti.leave.entity.TBusActivitiLeaveEntity;
import cn.com.lzt.useractiviti.sameleveltransfer.entity.TBusActivitiSamelevelTransferEntity;
import cn.com.lzt.useractiviti.service.UserActivitiServiceI;
import cn.com.lzt.userarrangedetail.entity.UserArrangeDetailEntity;
import cn.com.lzt.userchangeslog.entity.UserChangesLogEntity;
import cn.com.lzt.userwagestrategy.entity.UserWagestrategyEntity;
import com.dingtalk.open.client.api.model.corp.CorpUserDetail;
import org.activiti.engine.IdentityService;
import org.activiti.engine.identity.User;
import org.activiti.engine.identity.UserQuery;
import org.jeecgframework.core.common.hibernate.qbc.CriteriaQuery;
import org.jeecgframework.core.common.service.impl.CommonServiceImpl;
import org.jeecgframework.core.constant.Globals;
import org.jeecgframework.core.util.*;
import org.jeecgframework.web.system.pojo.base.*;
import org.jeecgframework.web.system.service.SystemService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.io.Serializable;

import org.jeecgframework.web.cgform.enhance.CgformEnhanceJavaInter;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;

@Service
@Transactional
public class UserActivitiServiceImpl extends CommonServiceImpl implements UserActivitiServiceI {

	@Autowired
	private SystemService systemService;

	@Autowired
	private PersonnelBaseArchivesManageServiceI personnelBaseArchivesManageService;

	@Autowired
	private IdentityService identityService;

	@Autowired
	private UseractivitiDataServiceI useractivitiDataService;

	@Autowired
	private DingdingService dingdingService;

 	public void delete(TBusActivitiUserPersonnelEntity entity) throws Exception{
 		super.delete(entity);
 		//执行删除操作增强业务
		this.doDelBus(entity);
 	}
 	
 	public Serializable save(TBusActivitiUserPersonnelEntity entity) throws Exception{
 		Serializable t = super.save(entity);
 		//执行新增操作增强业务
 		this.doAddBus(entity);
 		return t;
 	}
 	
 	public void saveOrUpdate(TBusActivitiUserPersonnelEntity entity) throws Exception{
 		super.saveOrUpdate(entity);
 		//执行更新操作增强业务
 		this.doUpdateBus(entity);
 	}
 	
 	/**
	 * 新增操作增强业务
	 * @param t
	 * @return
	 */
	private void doAddBus(TBusActivitiUserPersonnelEntity t) throws Exception{
		//-----------------sql增强 start----------------------------
	 	//-----------------sql增强 end------------------------------
	 	
	 	//-----------------java增强 start---------------------------
	 	//-----------------java增强 end-----------------------------
 	}
 	/**
	 * 更新操作增强业务
	 * @param t
	 * @return
	 */
	private void doUpdateBus(TBusActivitiUserPersonnelEntity t) throws Exception{
		//-----------------sql增强 start----------------------------
	 	//-----------------sql增强 end------------------------------
	 	
	 	//-----------------java增强 start---------------------------
	 	//-----------------java增强 end-----------------------------
 	}
 	/**
	 * 删除操作增强业务
	 * @return
	 */
	private void doDelBus(TBusActivitiUserPersonnelEntity t) throws Exception{
	    //-----------------sql增强 start----------------------------
	 	//-----------------sql增强 end------------------------------
	 	
	 	//-----------------java增强 start---------------------------
	 	//-----------------java增强 end-----------------------------
 	}
 	

 	/**
	 * 替换sql中的变量
	 * @param sql
	 * @param t
	 * @return
	 */
 	public String replaceVal(String sql,TBusActivitiUserPersonnelEntity t){
 		sql  = sql.replace("#{UUID}",UUID.randomUUID().toString());
 		return sql;
 	}
 	
 	/**
	 * 执行JAVA增强
	 */
 	private void executeJavaExtend(String cgJavaType,String cgJavaValue,Map<String,Object> data) throws Exception {
 		if(StringUtil.isNotEmpty(cgJavaValue)){
			Object obj = null;
			try {
				if("class".equals(cgJavaType)){
					//因新增时已经校验了实例化是否可以成功，所以这块就不需要再做一次判断
					obj = MyClassLoader.getClassByScn(cgJavaValue).newInstance();
				}else if("spring".equals(cgJavaType)){
					obj = ApplicationContextUtil.getContext().getBean(cgJavaValue);
				}
				if(obj instanceof CgformEnhanceJavaInter){
					CgformEnhanceJavaInter javaInter = (CgformEnhanceJavaInter) obj;
					javaInter.execute("t_bus_activiti_user_personnel",data);
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new Exception("执行JAVA增强出现异常！");
			} 
		}
 	}

	@Override
	public void saveActivitiUser(String activitiUserId) {
		TBusActivitiUserPersonnelEntity au = findUniqueByProperty(TBusActivitiUserPersonnelEntity.class,"id" , activitiUserId);
		String idcard = au.getIdcard();
		TSUser existUser = findUniqueByProperty(TSUser.class,"idcard" , idcard);
		if(existUser!=null){//用户存在 离职后重新入职
			updateActivitiUser(existUser,au);
			return;
		}
		TSUser user = new TSUser();
		BeanUtils.copyProperties(au, user);
		//saveUser
		user.setId(null);
		user.setStatus(Globals.User_Normal);
		user.setDeleteFlag(Globals.Delete_Normal);
		user.setActivitiSync(Globals.activitiSync_YES);
		user.setDevFlag("0");
		user.setDepartid(au.getDepartId());
		user.setCreateDate(new Date());
		user.setUpdateBy(null);
		user.setUpdateDate(null);
		user.setUpdateName(null);
		String yxyg_roleid = null;// 一线员工的角色ID
		List<TSRole> yxyg_roleList = systemService.findByProperty(TSRole.class, "roleCode", Globals.roleCode_yxyg);
		if(yxyg_roleList != null && yxyg_roleList.size() > 0){
			yxyg_roleid = yxyg_roleList.get(0).getId();// 一线员工的角色ID
		}

		String roleid = null;
		if(Globals.userType_1.equals(user.getUserType())){
			roleid = yxyg_roleid;
		}
		// 得到默认密码
		String password = ResourceUtil.getConfigByName("defaultPassword");

		if(user.getRealName() != null) {
			String trim = user.getRealName().replaceAll(" ", "");
			user.setRealName(trim);
		}
		if(user.getIdcard() != null) {
			String up = user.getIdcard().toUpperCase();
			user.setIdcard(up);
		}
		user.setPassword(PasswordEncodeUtil.getMD5(password));
		user.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());
		save(user);

		//saveUser
		try {
			//处理附件追加用户默认固定附件类型
			personnelBaseArchivesManageService.dealAccessoryIsFixedDefault(user.getId());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		if (StringUtil.isNotEmpty(roleid)) {
			saveRoleUser(user, roleid);
		}
		TSDepart tsDepart = saveUserOrgList(user);

		if(StringUtil.isNotEmpty(tsDepart.getDingdepartid())) {
			List<Long> departIdList = new ArrayList<Long>();
			departIdList.add(Long.valueOf(tsDepart.getDingdepartid()));

			CorpUserDetail corpUserDetail = dingdingService.getUser(user.getId());
			boolean dingFlg = false;
			if(StringUtil.isNotEmpty(corpUserDetail.getUserid())) {
				dingFlg = dingdingService.updateUser(user.getId(), user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
			} else {
				dingFlg = dingdingService.createUser(user.getId(), user.getRealName(), departIdList,user.getMobilePhone(), user.getUserName());
			}
			if(dingFlg) {
				user.setDingIsSynchronization(Globals.DingIsSynchronization_YES.toString());
				systemService.updateEntitie(user);
			}else{
				user.setDingIsSynchronization(Globals.DingIsSynchronization_NO.toString());
			}
		}
		// 员工类型：0管理员工；1普通员工
		String userType = oConvertUtils.getString(user.getUserType());
		//保证员工类型非空  如果为空  给定默认值为  普通员工
		if (oConvertUtils.isEmpty(userType)) {
			userType = Globals.userType_1;
			user.setUserType(userType);
		}
		//根据员工类型  设定是否 同步工作流引擎
		user.setActivitiSync(userType.equals(Globals.userType_1)?Globals.activitiSync_NO:Globals.activitiSync_YES);

		if (Globals.userType_0.equals(userType)) {
			try {
				UserQuery userQuery = identityService.createUserQuery();
				List<User> activitiUsers = userQuery.userId(user.getUserName()).list();
				//根据用户名称去工作流表中查询，如果列表中没有此人， 新建， 如果列表中有， 则更新
				if (ListUtils.isNullOrEmpty(activitiUsers)) {
					saveActivitiUser(user);
				} else if (activitiUsers.size() == 1) {
					cloneAndSaveActivitiUser(user, activitiUsers.get(0));
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		updateEntitie(user);

		PersonnelBaseArchivesManageEntity personel = new PersonnelBaseArchivesManageEntity();
		BeanUtils.copyProperties(au,personel);
		personel.setUserid(user.getId());
		//计算合同结束时间
		Date csTime = au.getContractStime();
		Calendar c = Calendar.getInstance();
		c.setTime(csTime);
		c.add(Calendar.YEAR,au.getContractLong());
		Date ceTime = c.getTime();
		personel.setContractEtime(ceTime);
		DutiesEntity dutiesEntity = getEntity(DutiesEntity.class, au.getDuty());
		personel.setBelongDutiesid(au.getDuty());
		personel.setManagerType(dutiesEntity.getManageType());
		personel.setInPostid(dutiesEntity.getPost());
		personel.setManagerType(dutiesEntity.getManageType());
		personel.setIfremind(Globals.SHIFOU_01_1);
		personel.setAutoCorrection(Globals.SHIFOU_01_1);
		personel.setPositionStatus(Globals.JOBSTATUS_1);
		this.saveUserChangesLog(user.getId(), "0", personel.getPositionStatus());
		// 试用期为【无】时，转正日期=合同开始日期
		if(Globals.SHIYONGQI_0.equals(personel.getTrialPeriod().toString())) {
			personel.setCorrectionDate(personel.getContractStime());
		}
		personel.setCreateDate(new Date());
		personel.setUpdateBy(null);
		personel.setUpdateDate(null);
		personel.setUpdateName(null);
		personel.setId(null);
		save(personel);
		au.setUserId(user.getId());
		updateEntitie(au);
	}

	private void updateActivitiUser(TSUser existUser, TBusActivitiUserPersonnelEntity au) {
		PersonnelBaseArchivesManageEntity pe = systemService.findUniqueByProperty(PersonnelBaseArchivesManageEntity.class, "userid", existUser.getId());
		if(pe.getLeaveDate() !=null){//确认离职后操作
			String oldPeId = pe.getId();
			BeanUtils.copyProperties(au,pe);
			pe.setId(oldPeId);
			pe.setLeaveDate(null);
			Date csTime = au.getContractStime();
			Calendar c = Calendar.getInstance();
			c.setTime(csTime);
			c.add(Calendar.YEAR,au.getContractLong());
			Date ceTime = c.getTime();
			pe.setContractEtime(ceTime);
			DutiesEntity dutiesEntity = getEntity(DutiesEntity.class, au.getDuty());
			pe.setBelongDutiesid(au.getDuty());
			pe.setManagerType(dutiesEntity.getManageType());
			pe.setInPostid(dutiesEntity.getPost());
			pe.setManagerType(dutiesEntity.getManageType());
			pe.setIfremind(Globals.SHIFOU_01_1);
			pe.setAutoCorrection(Globals.SHIFOU_01_1);
			pe.setPositionStatus(Globals.JOBSTATUS_1);
			this.saveUserChangesLog(existUser.getId(), "0", pe.getPositionStatus());
			// 试用期为【无】时，转正日期=合同开始日期
			if(Globals.SHIYONGQI_0.equals(pe.getTrialPeriod().toString())) {
				pe.setCorrectionDate(pe.getContractStime());
			}
			pe.setUpdateDate(new Date());
			updateEntitie(pe);
			au.setUserId(pe.getUserid());
			updateEntitie(au);
		}
	}

	protected void saveActivitiUser(TSUser user) {
		String userId = oConvertUtils.getString(user.getUserName());
		User activitiUser = identityService.newUser(userId);
		cloneAndSaveActivitiUser(user, activitiUser);
	}
	protected void cloneAndSaveActivitiUser(TSUser user, User activitiUser) {
		activitiUser.setFirstName(user.getRealName());
		activitiUser.setLastName(user.getRealName());
		activitiUser.setPassword(user.getPassword());
		activitiUser.setEmail(user.getEmail());
		identityService.saveUser(activitiUser);

	}

	private TSDepart saveUserOrgList(TSUser user) {
		String orgIds = user.getDepartid();//组织机构ID数组
//-------------------------设置该用户的组织机构关系-------------------------
		List<String> orgIdList = extractIdListByComma(orgIds);
		String orgId = orgIdList.get(0);//目前规定一个人只能有一个组织机构

		//查询该用户所有的组织机构
		TSDepart depart = systemService.getEntity(TSDepart.class,orgId);
		TSUserOrg userOrg = new TSUserOrg();
		userOrg.setTsUser(user);
		userOrg.setTsDepart(depart);
		userOrg.setIfpluralism(Globals.PLURALISM_NO.toString());
		userOrg.setStatus(Globals.BELONG_STATUS_NORMAL.toString());
		userOrg.setIntime(new Date());
		systemService.save(userOrg);
		return depart;
	}

	protected List<String> extractIdListByComma(String ids) {
		List<String> result = new ArrayList<String>();
		if (StringUtils.hasText(ids)) {
			for (String id : ids.split(",")) {
				if (StringUtils.hasLength(id)) {
					result.add(id.trim());
				}
			}
		}

		return result;
	}
	protected void saveRoleUser(TSUser user, String roleidStr) {
		String[] roleids = roleidStr.split(",");
		for (int i = 0; i < roleids.length; i++) {
			TSRoleUser rUser = new TSRoleUser();
			TSRole role = systemService.getEntity(TSRole.class, roleids[i]);
			rUser.setTSRole(role);
			rUser.setTSUser(user);
			systemService.save(rUser);
		}
	}
	private void saveUserChangesLog(String userId, String ifpayment, String positionStatus) {
		// 查询用户信息
		TSBaseUser userInfo = systemService.get(TSBaseUser.class, userId);

		// 查询主组织
		StringBuilder mainOrgSql = new StringBuilder();
		mainOrgSql.append(" SELECT ");
		mainOrgSql.append(" org_id orgId");
		mainOrgSql.append(" FROM t_s_user_org ");
		mainOrgSql.append(" WHERE ");
		mainOrgSql.append(" user_id = '" + userId + "'");
		mainOrgSql.append(" AND status = '0' ");
		mainOrgSql.append(" AND ifpluralism <> '1' ");
		List<Map<String, Object>> mainOrgMapList = systemService.findForJdbc(mainOrgSql.toString());
		String mainOrgId = "";
		if(mainOrgMapList.size() > 0) {
			mainOrgId = (String)mainOrgMapList.get(0).get("orgId");
		}

		// 缴金人员，入职，显示人员变动信息，缴金状态"待缴金"
		// 协议人员，入职，显示人员变动信息，缴金状态为空，状态栏为空
		// 缴金单位，关联到员工工资策略中的社保单位
		// 查询登录人名字
		String loginUserName = ResourceUtil.getSessionUser().getRealName();

		UserChangesLogEntity userChangesLogEntity = new UserChangesLogEntity();
		userChangesLogEntity.setChangeTime(new Date());
		userChangesLogEntity.setUserCode(userInfo.getUserName());
		userChangesLogEntity.setUserName(userInfo.getRealName());
		userChangesLogEntity.setBelongUnitid(mainOrgId);
		userChangesLogEntity.setInUnitid("");
		if(Globals.JOBSTATUS_1.equals(positionStatus)) {
			userChangesLogEntity.setChangeType(Globals.CHANGE_TYPE_RUZHI);
		}
		if(Globals.JOBSTATUS_2.equals(positionStatus)) {
			userChangesLogEntity.setChangeType(Globals.CHANGE_TYPE_ZHUANZHENG);
		}
		userChangesLogEntity.setApplicant(loginUserName);
		if(Globals.SHIFOU_01_1.equals(ifpayment)) {
			String payUnit = "";
			String userWagestrategyHql = "from UserWagestrategyEntity where userid = ?";
			List<UserWagestrategyEntity> UserWagestrategyEntityList = systemService.findHql(userWagestrategyHql,userId);
			if(UserWagestrategyEntityList.size() > 0) {
				String socialSecurityStrategyid = UserWagestrategyEntityList.get(0).getSocialSecurityStrategyid();
				// 查询用户信息
				SocialSecurityStrategyEntity socialSecurityStrategyEntity = systemService.get(SocialSecurityStrategyEntity.class, socialSecurityStrategyid);
				if(null != socialSecurityStrategyEntity) {
					payUnit = socialSecurityStrategyEntity.getSocialSecurityUnit();
				}
			}
			userChangesLogEntity.setPayUnit(payUnit);
			userChangesLogEntity.setPayRemindStatus(Globals.PAY_REMIND_STATUS_0);
		} else {
			userChangesLogEntity.setPayUnit("");
			userChangesLogEntity.setPayRemindStatus("");
		}
		systemService.save(userChangesLogEntity);
	}

	@Override
	public void samelevelTransfer(String busid) {
		TBusActivitiSamelevelTransferEntity entity = systemService.getEntity(TBusActivitiSamelevelTransferEntity.class,busid);
		useractivitiDataService.userLevelTransfer(entity.getUserid(),entity.getInUnitid(),entity.getNewDutiesid(),entity.getCreateName(),Globals.SAMELEVEL_TRANSFER_TYPE);
	}



	@Override
	public void userLeave(String busid) {
		TBusActivitiLeaveEntity entity = systemService.getEntity(TBusActivitiLeaveEntity.class, busid);
		Date leaveDate = entity.getLeaveDate();
		if(leaveDate.getTime()>System.currentTimeMillis()){
			return;
		}
		boolean isDismiss = "citui".equals(entity.getLeaveType());
		useractivitiDataService.userLeave(entity.getUserid(),isDismiss,entity.getLeaveDate(),entity.getCreateName());
		entity.setIsHandle(Globals.SHIFOU_01_1);
		save(entity);
	}

	@Override
	public void userLeaveForDate() {
		List<TBusActivitiLeaveEntity> list = findHql("from TBusActivitiLeaveEntity where bpmStatus=? and leaveDate<?  and isHandle=? "
				,Globals.BPM_STATUS_FINISHED.toString(),new Date(),Globals.SHIFOU_01_0);
		for(TBusActivitiLeaveEntity entity :list){
			userLeave(entity.getId());
		}
	}
}