YanCheng_Metrology/Assets/Scripts/Project/Manager/DataManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Xml;
using System.IO;
using System.Linq;

/// <summary>
/// 数据管理类
/// </summary>
public class DataManager : BaseManager<DataManager>
{
    private DataManager()
    {
    }

    /// <summary>
    /// 系统科目配置数据
    /// </summary>
    public D_System d_System;
    ///// <summary>
    ///// 方案
    ///// </summary>
    //private Dictionary<int, TB_Scheme> schemeDic = new Dictionary<int, TB_Scheme>();

    ///// <summary>
    ///// 流程
    ///// </summary>
    //private Dictionary<int, TB_Process> processDic = new Dictionary<int, TB_Process>();

    ///// <summary>
    ///// 子流程
    ///// </summary>
    //private Dictionary<int, TB_SubProcess> subProcessDic = new Dictionary<int, TB_SubProcess>();

    ///// <summary>
    ///// 子流程步骤
    ///// </summary>
    //private Dictionary<int, TB_SubProcessStep> subProcessStepDic = new Dictionary<int, TB_SubProcessStep>();

    ///// <summary>
    ///// 虚拟仿真系统
    ///// </summary>
    //private Dictionary<int, TB_System> systemDic = new Dictionary<int, TB_System>();

    /// <summary>
    /// 设备类型
    /// </summary>
    private Dictionary<int, TB_DeviceType> deviceTypeDic = new Dictionary<int, TB_DeviceType>();

    /// <summary>
    /// 工具材料
    /// </summary>
    private Dictionary<int, TB_ToolAndMaterial> toolAndMaterialDic = new Dictionary<int, TB_ToolAndMaterial>();



    /// <summary>
    /// 初始化
    /// </summary>
    public void Init()
    {
        //设备类型
        ReadDeviceType(Application.streamingAssetsPath+ "/Setting/设备类型.xml");
        //工具材料
        ReadToolAndMaterial(Application.streamingAssetsPath + "/Setting/工具材料.xml");
        //科目
        Directory.GetFiles(Application.streamingAssetsPath + "/Setting/科目").ToList().ForEach(a => 
        {
            if(Path.GetExtension(a)==".xml")
                ReadSubecjtXML(a);
        });


        //schemeDic = GameManager.BinaryMgr.GetTable<TB_SchemeContainer>().dataDic;
        //processDic = GameManager.BinaryMgr.GetTable<TB_ProcessContainer>().dataDic;
        //subProcessDic = GameManager.BinaryMgr.GetTable<TB_SubProcessContainer>().dataDic;
        //subProcessStepDic = GameManager.BinaryMgr.GetTable<TB_SubProcessStepContainer>().dataDic;
        //systemDic = GameManager.BinaryMgr.GetTable<TB_SystemContainer>().dataDic;
        //deviceTypeDic = GameManager.BinaryMgr.GetTable<TB_DeviceTypeContainer>().dataDic;
        //toolAndMaterialDic = GameManager.BinaryMgr.GetTable<TB_ToolAndMaterialContainer>().dataDic;
    }


    private void ReadDeviceType(string path)
    {
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(path);
        var nodes = xmlDoc.SelectNodes("root/DeviceType");
        foreach (XmlNode node in nodes)
        {
            TB_DeviceType tB_DeviceType = new TB_DeviceType();
            tB_DeviceType.id = int.Parse(node.Attributes["id"].Value);
            tB_DeviceType.deviceTypeName = node.Attributes["deviceTypeName"].Value;
            deviceTypeDic.Add(tB_DeviceType.id, tB_DeviceType);
        }
    }
    private void ReadToolAndMaterial(string path)
    {
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(path);
        var nodes=xmlDoc.SelectNodes("root/ToolMaterial");
        foreach (XmlNode node in nodes)
        {
            TB_ToolAndMaterial tB_ToolAndMaterial = new TB_ToolAndMaterial();
            tB_ToolAndMaterial.id= int.Parse(node.Attributes["id"].Value);
            tB_ToolAndMaterial.objName = node.Attributes["objName"].Value;
            tB_ToolAndMaterial.type= int.Parse(node.Attributes["type"].Value);
            toolAndMaterialDic.Add(tB_ToolAndMaterial.id, tB_ToolAndMaterial);
        }
    }
    private void ReadSubecjtXML(string path)
    {
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(path);
        //系统
        XmlNode sysnode = xmlDoc.SelectSingleNode("TB_System");
        d_System = new D_System();
        d_System.id = int.Parse(sysnode.Attributes["id"].Value);
        d_System.systemName = sysnode.Attributes["systemName"].Value;
        d_System.loadName = sysnode.Attributes["loadName"].Value;
        d_System.titleName = sysnode.Attributes["titleName"].Value;
        //检索不同科目文件
        //科目
        XmlNode subjectnode = xmlDoc.SelectSingleNode("TB_System/Subject");
        D_Scheme subject = new D_Scheme();
        subject.id = int.Parse(subjectnode.Attributes["id"].Value);
        subject.deviceTypeId = int.Parse(subjectnode.Attributes["deviceTypeId"].Value);
        subject.schemeName = subjectnode.Attributes["schemeName"].Value;
        subject.deviceMap = subjectnode.Attributes["deviceMap"].Value;
        //subject.schemeDes = subjectnode.Attributes["schemeDes"].Value;
        subject.ToolOrMaterilOrDevice = subjectnode.Attributes["ToolOrMaterilOrDevice"].Value;

        d_System.subjects.Add(subject);

        //流程
        int processindex = 1;
        int stepindex=1;
        int operationIndex = 1;
        var processNodes = xmlDoc.SelectNodes("TB_System/Subject/Process");
        foreach (XmlNode processNode in processNodes)
        {
            D_Process process = new D_Process();
            process.schemeId = subject.id;
            process.processName = processNode.Attributes["processName"].Value;
            //process.processDes = processNode.Attributes["processDes"].Value;
            subject.processes.Add(process);
            //process.id = subject.processes.IndexOf(process)+1;
            process.id = processindex;
            processindex++;
            //步骤
            foreach (XmlNode stepNode in processNode.ChildNodes)
            {
                D_SubProcess step = new D_SubProcess();
                step.processId = process.id;
                step.schemeId = subject.id;
                step.subProcessName = stepNode.Attributes["subProcessName"].Value;
                //step.tipTitle = stepNode.Attributes["tipTitle"].Value;
                step.tips = stepNode.Attributes["tips"].Value;
                //step.precondition= stepNode.Attributes["precondition"].Value;
                //step.isPrecondition= bool.Parse(stepNode.Attributes["isPrecondition"].Value);
                process.subProcesses.Add(step);
                //step.id = process.subProcesses.IndexOf(step)+1;
                step.id = stepindex;
                stepindex++;

                foreach (XmlNode operationNode in stepNode.ChildNodes)
                {
                    //操作
                    D_SubProcessStep operation = new D_SubProcessStep();
                    operation.processId = process.id;
                    operation.schemeId = subject.id;
                    operation.subProcessId = step.id;
                    operation.subProcessStepName = operationNode.Attributes["subProcessStepName"].Value;
                    operation.triggerID = operationNode.Attributes["triggerID"].Value;
                    operation.tipTitle = operationNode.Attributes["tipTitle"].Value;
                    operation.precondition = operationNode.Attributes["precondition"].Value;
                    //operation.isPrecondition = bool.Parse(operationNode.Attributes["isPrecondition"].Value);
                    step.subProcessStepes.Add(operation);
                    operation.id = operationIndex;
                    operationIndex++;
                    //operation.id = step.subProcessStepes.IndexOf(operation) + 1;
                }
            }
        }
    }

    public Dictionary<int, TB_DeviceType> GetAllDeviceTypes()
    {
        return deviceTypeDic;
    }

    /// <summary>
    /// 获取当前系统所有的方案
    /// </summary>
    /// <returns></returns>
    public List<D_Scheme> GetAllSchemeName()
    {
        return d_System.subjects;

        //var allSchemeList = new List<D_Scheme>();
        //foreach (var item in schemeDic.Values)
        //{
        //    if (item.systemId == GameManager.Instance.systemId)
        //        allSchemeList.Add(item);
        //}

        //return allSchemeList;
    }

    /// <summary>
    /// 根据方案 ToolOrMaterilOrDevice 获取当前系统全部工器具和材料
    /// </summary>
    /// <returns></returns>
    public List<D_ToolAndMaterialData> GetCurrentSystemToolAndMaterials(string tOrMOrD)
    {
        var currentSystemToolAndMaterials = new List<D_ToolAndMaterialData>();

        string[] tmdTemp = tOrMOrD.Split(',');

        for (int i = 0; i < tmdTemp.Length; i++)
        {
            int index = i;
            foreach (var item in toolAndMaterialDic.Values)
            {
                if (item.id == int.Parse(tmdTemp[index]))
                {
                    D_ToolAndMaterialData d_ToolAndMaterialData = new D_ToolAndMaterialData();
                    d_ToolAndMaterialData.id = item.id;
                    d_ToolAndMaterialData.objName = item.objName;
                    d_ToolAndMaterialData.type = item.type;
                    d_ToolAndMaterialData.prefabName = item.prefabName;
                    d_ToolAndMaterialData.iconSpriteName = item.iconSpriteName;
                    currentSystemToolAndMaterials.Add(d_ToolAndMaterialData);
                }
            }
        }
        return currentSystemToolAndMaterials;
    }




    /// <summary>
    /// 获取D_Scheme
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public D_Scheme GetSchemeData(int id)
    {
        return d_System.subjects.Find(x => x.id == id);
        //D_Scheme d_Scheme = new D_Scheme();
        ////获取方案数据
        //if (schemeDic.ContainsKey(id))
        //{
        //    d_Scheme.id = schemeDic[id].id;
        //    d_Scheme.schemeName = schemeDic[id].schemeName;
        //    d_Scheme.ToolOrMaterilOrDevice = schemeDic[id].ToolOrMaterilOrDevice;
        //}
        //d_Scheme.processes = GetD_Processes(d_Scheme.id);
        //return d_Scheme;
    }

    #region 老的读取
    ///// <summary>
    ///// 根据方案Id 获取流程列表
    ///// </summary>
    ///// <param name="schemeId"></param>
    ///// <returns></returns>
    //private List<D_Process> GetD_Processes(int schemeId)
    //{
    //    List<D_Process> d_Processes = new List<D_Process>();
    //    //获取方案流程数据
    //    foreach (var item in processDic.Values)
    //    {
    //        if (item.schemeId == schemeId)
    //        {
    //            D_Process d_Process = new D_Process();
    //            d_Process.id = item.id;
    //            d_Process.processName = item.processName;
    //            int processId = item.id;
    //            d_Process.subProcesses = GetD_SubProcesses(schemeId, processId);
    //            d_Processes.Add(d_Process);
    //        }
    //    }

    //    return d_Processes;
    //}

    ///// <summary>
    ///// 根据方案Id,流程Id ,获取子流程列表
    ///// </summary>
    ///// <param name="schemeId"></param>
    ///// <param name="processId"></param>
    ///// <returns></returns>
    //public List<D_SubProcess> GetD_SubProcesses(int schemeId, int processId)
    //{
    //    List<D_SubProcess> d_SubProcesses = new List<D_SubProcess>();
    //    foreach (var item in subProcessDic.Values)
    //    {
    //        if (item.schemeId == schemeId && item.processId == processId)
    //        {
    //            D_SubProcess d_SubProcess = new D_SubProcess();
    //            d_SubProcess.id = item.id;
    //            d_SubProcess.schemeId = item.schemeId;
    //            d_SubProcess.processId = item.processId;
    //            d_SubProcess.subProcessName = item.subProcessName;
    //            d_SubProcess.isPrecondition = item.isPrecondition;
    //            d_SubProcess.precondition = item.precondition;
    //            d_SubProcess.tips = item.tips;
    //            int subProcessId = item.id;
    //            d_SubProcess.subProcessStepes = GetD_SubProcessSteps(schemeId, processId, subProcessId);
    //            d_SubProcesses.Add(d_SubProcess);
    //        }
    //    }

    //    return d_SubProcesses;
    //}

    ///// <summary>
    ///// 根据方案Id,流程Id,子流程Id  获取子流程步骤列表
    ///// </summary>
    ///// <param name="schemeId"></param>
    ///// <param name="processId"></param>
    ///// <param name="subProcessStepId"></param>
    ///// <returns></returns>
    //private List<D_SubProcessStep> GetD_SubProcessSteps(int schemeId, int processId, int subProcessId)
    //{
    //    List<D_SubProcessStep> d_SubProcessSteps = new List<D_SubProcessStep>();
    //    foreach (var step in subProcessStepDic.Values)
    //    {
    //        if (step.schemeId == schemeId && step.processId == processId && step.subProcessId == subProcessId)
    //        {
    //            D_SubProcessStep d_SubProcessStep = new D_SubProcessStep();
    //            d_SubProcessStep.id = step.id;
    //            d_SubProcessStep.schemeId = step.schemeId;
    //            d_SubProcessStep.processId = step.processId;
    //            d_SubProcessStep.subProcessId = step.subProcessId;
    //            d_SubProcessStep.subProcessStepName = step.subProcessStepName;
    //            d_SubProcessStep.isPrecondition = step.isPrecondition;
    //            d_SubProcessStep.precondition = step.precondition;
    //            d_SubProcessStep.triggerID = step.triggerID;
    //            d_SubProcessStep.tipTitle = step.tipTitle;
    //            d_SubProcessStep.score = step.score;
    //            d_SubProcessSteps.Add(d_SubProcessStep);
    //        }
    //    }

    //    return d_SubProcessSteps;
    //}


    //public List<int> GetSubProcessStepIDByTriggerID(int triggerID)
    //{
    //    List<TB_SubProcessStep> tb_subProcesssSteps = new List<TB_SubProcessStep>();
    //    List<int> stepIDsTemp = new List<int>();
    //    foreach (var item in subProcessStepDic.Values)
    //    {
    //        if (item.schemeId == GameManager.ProcessMgr.schemeID)
    //            tb_subProcesssSteps.Add(item);
    //    }
    //    foreach (var item in tb_subProcesssSteps)
    //    {
    //        if (string.IsNullOrEmpty(item.triggerID))
    //        {
    //            continue;
    //        }
    //        string[] subProcessStepToolID = item.triggerID.Split(',');
    //        for (int i = 0; i < subProcessStepToolID.Length; i++)
    //        {
    //            if (int.Parse(subProcessStepToolID[i]) == triggerID)
    //                stepIDsTemp.Add(item.id);
    //        }
    //    }
    //    return stepIDsTemp;
    //}
    #endregion

    /// <summary>
    /// 根据系统Id 获取系统信息
    /// </summary>
    /// <param name="systemId"></param>
    /// <returns></returns>
    public D_System GetSystemInfo(int systemId)
    {
        return d_System;
        //if (systemDic.ContainsKey(systemId))
        //{
        //    return systemDic[systemId];
        //}

        //return null;
    }

    /// <summary>
    /// 获取报告
    /// </summary>
    /// <param name="id"></param>
    public R_Scheme GetSchemeReport(int id)
    {
        R_Scheme r_Scheme = new R_Scheme();


        return r_Scheme;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    //public TB_Scheme GetTitleSpriteName(int id)
    //{
    //    if (schemeDic.ContainsKey(id))
    //    {
    //        return schemeDic[id];
    //    }

    //    return null;
    //}
}