jxyh/src/main/java/sys/sc/task/UpdateDataDailyTask.java

package sys.sc.task;

import com.alibaba.druid.support.logging.Log;
import com.alibaba.druid.support.logging.LogFactory;
import kd.bos.context.RequestContext;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.entity.DynamicObjectCollection;
import kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType;
import kd.bos.entity.EntityMetadataCache;
import kd.bos.entity.operate.result.OperationResult;
import kd.bos.exception.KDException;
import kd.bos.form.IFormView;
import kd.bos.orm.ORM;
import kd.bos.orm.query.QFilter;
import kd.bos.schedule.api.MessageHandler;
import kd.bos.schedule.executor.AbstractTask;
import kd.bos.sec.user.utils.UserOperationUtils;
import kd.bos.servicehelper.BusinessDataServiceHelper;
import kd.bos.servicehelper.operation.SaveServiceHelper;
import sys.sc.formplugin.ABillServiceHelper;
import sys.sc.opplugin.utils.InterFaceImgUtils;
import sys.sc.opplugin.utils.SftpClient;

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

/**
 * @author cjz
 * @date 2024/9/3 15:13
 * @description:获取日常数据更新组织和人员调度计划
 */
public class UpdateDataDailyTask extends AbstractTask {

    private static final Log log = LogFactory.getLog(UpdateDataDailyTask.class);
    public InterFaceImgUtils interFaceImgUtils=new InterFaceImgUtils("produceurl");    //服务器ip
    public String host=interFaceImgUtils.getServerName();
    //用户名
    public String username=interFaceImgUtils.getServerUser();
    //用户密码
    public String password=interFaceImgUtils.getServerPassword();
    //分割符
    public String splitsign=interFaceImgUtils.getServerSplit();
    //结尾符
    public String endsign=interFaceImgUtils.getServerEndsign();
    public int port= interFaceImgUtils.getProt();



    @Override
    public MessageHandler getMessageHandle() {
        return super.getMessageHandle();
    }

    @Override
    public void execute(RequestContext requestContext, Map<String, Object> map) throws KDException {
        String mes="---------------正在执行任务，读取文件数据更新组织和人员------------------";
        log.info(mes+requestContext);
        //文件路径
        String path=getFileUrl("organduserurl");
        try {

            //获取连接对象
            SftpClient sftpClient=new SftpClient(host,username,password,port);
            sftpClient.connect();
            //读取文件更新基础资料
            updatebasicdata(sftpClient.fileInputStream(path));
            //关闭连接
            sftpClient.disconnect();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        //更新组织
        log.info("----------------更新组织中---------------------");
        updateorg();
        //更新人员
        log.info("----------------更新人员中-------------------");
        updateperson();
    }
    //读取文件更新基础资料
    public void updatebasicdata(InputStream inputStream)
    {
        //读取文件写入基础资料中
        try {
            DynamicObjectType dynamicObjectType = EntityMetadataCache.getDataEntityType("nckd_basicdata");
            List<String> selector = Arrays.asList(
                    "nckd_employeeid", "nckd_name", "nckd_gender", "nckd_nl", "nckd_zzmm",
                    "nckd_zgxl", "nckd_szdwname", "nckd_szdwcode", "nckd_orgidname", "nckd_orgidcode",
                    "nckd_yjbmname", "nckd_yjbmcode", "nckd_posidname", "nckd_posidcode", "nckd_yggxlb",
                    "nckd_status", "nckd_sjh"
            );
            List<DynamicObject> createdataList = new ArrayList<>();
            List<DynamicObject> updatedataList = new ArrayList<>();
            //查出所有现有的数据
            DynamicObject[] existingData = BusinessDataServiceHelper
                    .load(dynamicObjectType.getName(), String.join(",", selector) + ",nckd_updatedate,nckd_isdelete", null);
            Map<String, DynamicObject> existingDataMap = new HashMap<>();
            for (DynamicObject obj : existingData) {
                existingDataMap.put(obj.getString("nckd_employeeid"), obj);
            }
            Set<String> processedGonghaoSet = new HashSet<>();
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    //去掉换行符|$|
                    line = line.replace(endsign, "");
                    //
空格符号，根据这个符号分割
                    String[] fields = line.split(splitsign);
                    //如果获取的数据行不等于预设字段的行，则跳过这行数据
                    if (fields.length != selector.size()) {
                        continue;
                    }
                    //获取工号
                    String gonghao = fields[0];
                    boolean isUpdated = false;
                    DynamicObject data;
                    processedGonghaoSet.add(gonghao);
                    if (existingDataMap.containsKey(gonghao)) {
                        //获取对应工号的数据
                        data = existingDataMap.get(gonghao);
                        for (int i = 0; i < selector.size(); i++) {
                            String fieldName = selector.get(i);
                            String newValue = fields[i];
                            String existingValue = data.getString(fieldName);
                            //判断数据是否与之前的数据相同，不相同则更新
                            if (!Objects.equals(existingValue, newValue)) {
                                data.set(fieldName, newValue);
                                isUpdated = true;
                            }
                        }
                        //更新了数据则设置数据更新的时间
                        if (isUpdated) {
                            data.set("nckd_updatedate", new Date());
                            updatedataList.add(data);
                        }
                    } else {
                        //不存在这条数据则新增一条到data中
                        data = new DynamicObject(dynamicObjectType);
                        for (int i = 0; i < selector.size(); i++) {
                            data.set(selector.get(i), fields[i]);
                        }
                        Date now = new Date();
                        data.set("nckd_createdate", now);
                        data.set("nckd_updatedate", now);
                        createdataList.add(data);
                    }
                }
            }
            for (Map.Entry<String, DynamicObject> entry : existingDataMap.entrySet()) {
                String gonghao = entry.getKey();
                DynamicObject data = entry.getValue();

                if (!processedGonghaoSet.contains(gonghao)) {
                    data.set("nckd_isdelete", true);
                    updatedataList.add(data);
                }
            }
            //新增数据不为空则更新到数据库中
            if (!createdataList.isEmpty()) {
                SaveServiceHelper.save(dynamicObjectType, createdataList.toArray(new DynamicObject[0]));
            }
            //更新的数据不为空，则更新到数据库中
            if (!updatedataList.isEmpty()) {
                SaveServiceHelper.save(updatedataList.get(0).getDynamicObjectType(), updatedataList.toArray(new DynamicObject[0]));
            }
            log.info("数据已成功保存！");
        } catch (IOException ex) {
            ex.printStackTrace();
            log.info("读取文件时发生错误：" + ex.getMessage());
        }
    }
    //根据基础资料更新组织
    public void updateorg()
    {
        // 获取形态信息 编码为 Orgform06 的 bos_org_pattern（部门组织）
        DynamicObject xingtaiinfo = BusinessDataServiceHelper.loadSingle(
                "bos_org_pattern", new QFilter[]{new QFilter("number", "=", "Orgform06")}
        );
        //获取形态信息，编码为 Orgform02 的bos_org_pattern（公司组织）
        DynamicObject cpyinfo = BusinessDataServiceHelper.loadSingle(
                "bos_org_pattern", new QFilter[]{new QFilter("number", "=", "Orgform02")}
        );
        // 查询 nckd_basicdata 表中需要更新的数据
        DynamicObject[] nckdData = BusinessDataServiceHelper.load(
                "nckd_basicdata",
                "id,nckd_szdwcode,nckd_szdwname,nckd_yjbmcode,nckd_yjbmname,nckd_orgidcode,nckd_orgidname",
                null
        );
        //行政组织
        DynamicObject rootOrg = BusinessDataServiceHelper.loadSingle(
                "bos_adminorg", new QFilter[]{new QFilter("number", "=", "jxyh")}
        );
        if (rootOrg == null) {
            log.info("指定的上级组织 'jxyh' 未找到！");
            return;
        }

        for (DynamicObject record : nckdData) {
            // 判断并创建或更新所在单位
            //所在单位编码
            String szdwbm = record.getString("nckd_szdwcode");
            //所在单位名称
            String szdwmc = record.getString("nckd_szdwname");
            DynamicObject org = BusinessDataServiceHelper.loadSingle(
                    "bos_adminorg", new QFilter[]{new QFilter("number", "=", szdwbm)}
            );
            //没有单位则创建
            if (org == null) {
                IFormView orgview = ABillServiceHelper.createAddView("bos_adminorg");
                //组织编码
                orgview.getModel().setValue("number", szdwbm);
                //组织名称
                orgview.getModel().setValue("name", szdwmc);
                //上级组织
                orgview.getModel().setValue("parent", rootOrg);
                //形态，设置形态为公司
                orgview.getModel().setValue("orgpattern", cpyinfo);
                //数据状态设置为已审核
                orgview.getModel().setValue("status", "C");
                //使用状态设置为可用
                orgview.getModel().setValue("enable", "1");
                OperationResult operationResult = ABillServiceHelper.saveOperate(orgview);
                //保存不成功
                if (!operationResult.isSuccess()) {

                }
                org = orgview.getModel().getDataEntity();
                //如果存在单位则检查单位名是否一致，不一致则更新
            }else if (!org.getString("name").equals(szdwmc))
            {
                //设置单位名称
                org.set("name",szdwmc);
                // 更新组织结构
                DynamicObjectCollection structureInfoCollection = org.getDynamicObjectCollection("structure");
                DynamicObject structureInfo = structureInfoCollection.get(0);
                //设置长名称
                structureInfo.set("fullname",rootOrg.getString("name")+"_"+szdwmc);
                SaveServiceHelper.update(org);
            }
            // 判断一级机构编码 在行政组织中是否存在，不存在则新增
            String yjjgbm = record.getString("nckd_yjbmcode");
            String yjjgmc = record.getString("nckd_yjbmname");
            //一级机构
            DynamicObject yjjg = BusinessDataServiceHelper.loadSingle("bos_adminorg", new QFilter[]{new QFilter("number", "=", yjjgbm)});
            if (yjjg == null) {
                IFormView yjjgView=ABillServiceHelper.createAddView("bos_adminorg");
                yjjgView.getModel().setValue("number", yjjgbm);
                yjjgView.getModel().setValue("name", yjjgmc);
                yjjgView.getModel().setValue("parent", org); // 父级组织为 org
                yjjgView.getModel().setValue("orgpattern", xingtaiinfo);
                yjjgView.getModel().setValue("status", "C");
                yjjgView.getModel().setValue("enable", "1");
                OperationResult yjjgOperationResult = ABillServiceHelper.saveOperate(yjjgView);
                if (!yjjgOperationResult.isSuccess()) {
                    // Handle the failure case here
                }
                yjjg = yjjgView.getModel().getDataEntity();
            } else if (!yjjg.getString("name").equals(yjjgmc)) {
                yjjg.set("name",yjjgmc);
                DynamicObjectCollection structureInfoCollection = yjjg.getDynamicObjectCollection("structure");
                DynamicObject structureInfo = structureInfoCollection.get(0);
                //设置长名称
                structureInfo.set("fullname",rootOrg.getString("name")+"_"+szdwmc+"_"+yjjgmc);
                SaveServiceHelper.update(yjjg);
            }
            // 判断所在部门编码 在行政组织中是否存在，不存在则新增
            String szbmbm = record.getString("nckd_orgidcode");
            String szbmmc = record.getString("nckd_orgidname");
            //所在部门
            DynamicObject szbm = BusinessDataServiceHelper.loadSingle("bos_adminorg", new QFilter[]{new QFilter("number", "=", szbmbm)});
            if (szbm == null) {
                IFormView szbmView=ABillServiceHelper.createAddView("bos_adminorg");
                szbmView.getModel().setValue("number", szbmbm);
                szbmView.getModel().setValue("name", szbmmc);
                szbmView.getModel().setValue("parent", yjjg); // 设置父级为 yjjg
                szbmView.getModel().setValue("orgpattern", xingtaiinfo);
                szbmView.getModel().setValue("status", "C"); // 设置状态
                szbmView.getModel().setValue("enable", "1"); // 设置为启用状态
                // 保存操作
                OperationResult szbmOperationResult = ABillServiceHelper.saveOperate(szbmView);
                if (!szbmOperationResult.isSuccess()) {
                    // 如果保存失败，可以在这里处理错误
                    log.info("保存部门失败！");
                    return;
                }
                if (szbmView.getModel() != null) {
                    szbm = szbmView.getModel().getDataEntity();
                } else {
                    log.info("保存后未能获取到部门数据！");
                    return;
                }
                log.info("行政组织数据已成功更新！");
            } else if (!szbm.getString("name").equals(szbmmc)) {
                szbm.set("name",szbmmc);
                DynamicObjectCollection structureInfoCollection = szbm.getDynamicObjectCollection("structure");
                DynamicObject structureInfo = structureInfoCollection.get(0);
                //设置长名称
                structureInfo.set("fullname",rootOrg.getString("name")+"_"+szdwmc+"_"+yjjgmc+"_"+szbmmc);
                SaveServiceHelper.update(szbm);
            }
        }
    }
    //根据基础资料更新人员
    public void updateperson()
    {
        // 从 nckd_basicdata 表中获取所有人员数据，假设通过某个条件查找
        DynamicObject[] personDataArray = BusinessDataServiceHelper.load(
                "nckd_basicdata",
                "id,nckd_employeeid,nckd_name,nckd_gender,nckd_nl,nckd_zzmm,nckd_zgxl,nckd_orgidname,nckd_orgidcode,nckd_posidname,nckd_posidcode,nckd_yggxlb,nckd_status,nckd_sjh",
                null
        );
        if (personDataArray == null || personDataArray.length == 0) {
            log.info("未从 nckd_basicdata 表中获取到任何人员数据！");
            return;
        }
        String msg="";
        for (DynamicObject personData : personDataArray) {
            log.info("-------------更新人员------------");
            // 获取工号
            String gonghao = personData.getString("nckd_employeeid");
            if (gonghao == null || gonghao.isEmpty()) {
                continue;
            }
            // 查询用户是否已存在
            DynamicObject existingUser = BusinessDataServiceHelper.loadSingle(
                    "bos_user", new QFilter[]{new QFilter("number", "=", gonghao)}
            );
            // 用户已存在，进行数据更新
            if (existingUser != null) {
                //初始化
                boolean isUpdated = false;
                // 比较并更新性别
                Object newGender = personData.get("nckd_gender");
                if (!newGender.equals(existingUser.get("gender"))) {
                    existingUser.set("gender", newGender);
                    isUpdated = true;
                }
                // 比较并更新手机号
                Object newPhone = personData.get("nckd_sjh");
                if (!newPhone.equals(existingUser.get("phone"))) {
                    existingUser.set("phone", newPhone);
                    isUpdated = true;
                }
                //更新部门和岗位
                DynamicObjectCollection existingDeptEntries = existingUser.getDynamicObjectCollection("entryentity");
                //人员部门分录
                DynamicObject existingDeptEntry = existingDeptEntries.isEmpty() ? null : existingDeptEntries.get(0);
                // 获取新的部门信息
                String deptCode = personData.getString("nckd_orgidcode");
                DynamicObject newOrgInfo = BusinessDataServiceHelper.loadSingle(
                        "bos_adminorg", new QFilter[]{new QFilter("number", "=", deptCode)}
                );
                boolean deptUpdated = false;
                if (newOrgInfo != null) {
                    if (existingDeptEntry == null) {
                        // 如果没有现有部门分录，则添加新的部门分录
                        existingDeptEntry = existingDeptEntries.addNew();
                        deptUpdated = true;
                    }
                    // 比较并更新部门信息
                    if (!deptCode.equals(existingDeptEntry.get("dpt.number"))) {
                        existingDeptEntry.set("dpt", newOrgInfo);
                        deptUpdated = true;
                    }
                    // 更新组织结构
                    DynamicObjectCollection structureInfoCollection = newOrgInfo.getDynamicObjectCollection("structure");
                    if (structureInfoCollection != null && !structureInfoCollection.isEmpty()) {
                        for (DynamicObject item:structureInfoCollection) {
                            //不为兼职则更新
                            if (!item.getBoolean("ispartjob")) {
                                DynamicObject structureInfo=item;//获取结构信息
                                if(existingDeptEntry.getDynamicObject("orgstructure")!=null){
                                    if (!structureInfo.getPkValue().equals(existingDeptEntry.getDynamicObject("orgstructure").getPkValue())) {
                                        existingDeptEntry.set("orgstructure", structureInfo.getPkValue());
                                        deptUpdated = true;
                                    }
                                }else{
                                    existingDeptEntry.set("orgstructure", structureInfo.getPkValue());
                                    deptUpdated = true;
                                }
                            }
                        }
                    }
                    // 标记是否需要保存
                    if (deptUpdated) {
                        isUpdated = true;
                    }
                } else {
                    log.info("未找到部门编码为 " + deptCode + " 的部门信息！");
                }
                // 获取新的岗位信息
                String postName = personData.getString("nckd_posidname");
                if (!postName.equals(existingDeptEntry.getString("position"))) {
                    existingDeptEntry.set("position", postName);
                    isUpdated = true;
                }
                // 如果有更新则保存
                if (isUpdated) {
                    SaveServiceHelper.save(new DynamicObject[]{existingUser});
                    msg+="工号为 " + gonghao + " 的用户信息已更新！";
                }
            } else {
                // 用户不存在，创建新用户
                DynamicObjectType userType = EntityMetadataCache.getDataEntityType("bos_user");
                DynamicObject userinfo = new DynamicObject(userType);
                ORM impl = ORM.create();
                userinfo.set("id", impl.genLongId("bos_user"));
                userinfo.set("number", gonghao);
                // 设置其他字段
                userinfo.set("gender", personData.get("nckd_gender"));
                //人员手机号
                userinfo.set("phone", personData.get("nckd_sjh"));
                // 设置其他固定字段
                userinfo.set("startdate", new Date());
                Calendar c = Calendar.getInstance();
                c.set(Calendar.YEAR, 2999);
                userinfo.set("enddate", c.getTime());
                userinfo.set("masterid", userinfo.get("id"));
                userinfo.set("enable", 1);
                userinfo.set("status", "C");
                userinfo.set("password", "8HrquJnZfyOkmmHkpGLXfg==");
                userinfo.set("isregisted", "1");
                userinfo.set("isactived", "1");
                userinfo.set("pswstrategy", "338333884850648064");
                userinfo.set("psweffectivedate", new Date());
                userinfo.set("useenddate", c.getTime());
                // 设置姓名和拼音
                String name = personData.getString("nckd_name");
                userinfo.set("name", name);
                String fullPinyin = UserOperationUtils.getFullSpellByName(name);
                String simplePinyin = UserOperationUtils.getFirstSpellByName(name);
                userinfo.set("fullpinyin", fullPinyin);
                userinfo.set("simplepinyin", simplePinyin);
                // 设置用户名
                String username = UserOperationUtils.getUserNameByFormatedFullPinyin(
                        (long) userinfo.getPkValue(), fullPinyin, null
                );
                userinfo.set("username", username);
                // 创建部门分录
                DynamicObjectCollection bmflList = userinfo.getDynamicObjectCollection("entryentity");
                DynamicObject bumeninfo = bmflList.addNew();
                // 获取部门编码并在 bos_adminorg 表中查找部门信息
                String deptCode = personData.getString("nckd_orgidcode");
                DynamicObject orginfo = BusinessDataServiceHelper.loadSingle(
                        "bos_adminorg", new QFilter[]{new QFilter("number", "=", deptCode)}
                );
                if (orginfo != null) {
                    bumeninfo.set("dpt", orginfo);
                    // 获取组织的分录集合 structure 的第一条数据
                    DynamicObjectCollection structureInfoCollection = orginfo.getDynamicObjectCollection("structure");
                    if (structureInfoCollection != null && !structureInfoCollection.isEmpty()) {
                        for (DynamicObject item:structureInfoCollection) {
                            //不为兼职则更新
                            if (!item.getBoolean("ispartjob")) {
                                DynamicObject structureInfo=item;//获取结构信息
                                bumeninfo.set("orgstructure",structureInfo.getPkValue());
                            }
                        }
                    } else {
                        log.info("部门编码为 " + deptCode + " 的部门缺少组织结构信息，跳过该记录。");
                    }
                }
                String postName = personData.getString("nckd_posidname");;
                bumeninfo.set("position", postName);
                //所在岗位名称
                String positionnumber = personData.getString("nckd_posidname");;
                bumeninfo.set("post", positionnumber);
                // 保存新用户信息
                SaveServiceHelper.save(new DynamicObject[]{userinfo});
                msg+="工号为 " + gonghao + " 的用户已创建！";
            }
        }
        if("".equals(msg)){
            log.info("没有需要更新或新增的人员");
        }else{
            log.info(msg);
        }
    }
    //根据接口配置信息获取组织人员，拼接服务器文件路径url,参数为urlcode接口配置信息编码
    public String getFileUrl(String urlcode)
    {
        //组织人员接口配置信息获取
        DynamicObject nckd_jkpzxx= BusinessDataServiceHelper
                .loadSingle("nckd_jkpzxx", new QFilter[]{new QFilter("number", "=", urlcode)});
        //取文件名
        String nckd_filename=nckd_jkpzxx.getString("nckd_filename");
        //获取文件路径
        String nckd_url=nckd_jkpzxx.getString("nckd_url");
        //当前日期
        Date currentDate=new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(currentDate);
        calendar.add(Calendar.DATE, -1); // 将日期减少一天
        //日期减少一天
        Date newDate = calendar.getTime();
        //转换日期格式
        SimpleDateFormat sf=new SimpleDateFormat("yyyyMMdd");
        String datestr=sf.format(newDate);
        //文件路径拼接
        //真实路径
        String realPath = nckd_url+datestr+"/"+nckd_filename;
        return realPath;
    }
    @Override
    public boolean isSupportReSchedule() {
        return super.isSupportReSchedule();
    }
}