using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using KPlan.Forms.Bean;
using KPlan.Util;
using System.Collections.ObjectModel;
using ModelObject = Teamcenter.Soa.Client.Model.ModelObject;
using Eplan.EplApi.MasterData;
using System.ComponentModel;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using MessageBox = System.Windows.MessageBox;
using Eplan.EplApi.DataModel.EObjects;

namespace KPlan.Forms {
   /// <summary>
   /// Interaction logic for KPartSync.xaml
   /// </summary>
   public partial class KPartSync : Window {
      public KPartSync(MDPartsDatabase mdPartsDatabase)
        {
         InitializeComponent();
         KUtil.SetOwnerWindow(this);
         this.mdPartsDatabase = mdPartsDatabase;
         bgWorker_Parts = new KBackgroundWorker(this);
         bgWorker_Parts.backgroundWorker.DoWork += Async_LoadParts;
         bgWorker_AddAll = new KBackgroundWorker(this);
         bgWorker_AddAll.backgroundWorker.DoWork += Async_AddAllUnsyncedParts;
         bgWorker_Apply = new KBackgroundWorker(this);
         bgWorker_Apply.backgroundWorker.DoWork += Async_Apply;

         bgWorker_Query = new KBackgroundWorker(this);
         bgWorker_Query.backgroundWorker.DoWork += Async_QueryParts;
         bgWorker_EPlan_to_TC = new KBackgroundWorker(this);
         bgWorker_EPlan_to_TC.backgroundWorker.DoWork += Async_EPlan_to_TC;
         bgWorker_EPlan_to_TC.backgroundWorker.RunWorkerCompleted += bgWorker_EPlan_to_TC_RunWorkerCompleted;
         bgWorker_TC_to_EPlan = new KBackgroundWorker(this);
         bgWorker_TC_to_EPlan.backgroundWorker.DoWork += Async_TC_to_EPlan;
         bgWorker_TC_to_EPlan.backgroundWorker.RunWorkerCompleted += bgWorker_EPlan_to_TC_RunWorkerCompleted;

         bgWorker_Revise = new KBackgroundWorker(this);
         bgWorker_Revise.backgroundWorker.DoWork += Async_Revise;
         bgWorker_Query_TC = new KBackgroundWorker(this);
         bgWorker_Query_TC.backgroundWorker.DoWork += Async_QueryTCParts;

         bgWorker_UploadPartsDB = new KBackgroundWorker(this);
         bgWorker_UploadPartsDB.backgroundWorker.DoWork += Async_UploadPartsDB;
         bgWorker_SyncErpCode = new KBackgroundWorker(this);
         bgWorker_SyncErpCode.backgroundWorker.DoWork += Async_SyncErpCode;
         bgWorker_AddGroup = new KBackgroundWorker(this);
         bgWorker_AddGroup.backgroundWorker.DoWork += Async_AddGroup;
         table_Sync_To_TC.ItemsSource = ePlanToTCData;
         TCUtil.DO_NOTHING();
      }

      public const string NOT_RELEASEED = "未发布";
      public const string NOT_SYNCED = "未同步";
      public const string PART_NOT_EXIST = "部件不存在";
      public const string APPLYING = "申请中";
      public const string SAP_NEED_ID = "SAP未分配ID";

      private List<DuplicateOrderNrBean> duplicateOrderNrBeans = new List<DuplicateOrderNrBean>();

      private MDPartsDatabase mdPartsDatabase;

      private KBackgroundWorker bgWorker_Parts;
      private KBackgroundWorker bgWorker_AddAll;
      private KBackgroundWorker bgWorker_Apply;
      private KBackgroundWorker bgWorker_Query;
      private KBackgroundWorker bgWorker_Query_TC;
      private KBackgroundWorker bgWorker_EPlan_to_TC;
      private KBackgroundWorker bgWorker_TC_to_EPlan;
      private KBackgroundWorker bgWorker_Revise;
      private KBackgroundWorker bgWorker_UploadPartsDB;
      private KBackgroundWorker bgWorker_SyncErpCode;
      private KBackgroundWorker bgWorker_AddGroup;
      private int sync_Success = 0;
      //private MDPart[] allParts;
      private Dictionary<MDPartsDatabaseItem.Enums.ProductTopGroup, EPlanGroup> topGroupMap = new Dictionary<MDPartsDatabaseItem.Enums.ProductTopGroup, EPlanGroup>();
      private ObservableCollection<KPartSyncDataRow> ePlanToTCData = new ObservableCollection<KPartSyncDataRow>();
      private ObservableCollection<SyncResult> errData = new ObservableCollection<SyncResult>();
      private class EPlanGroup {
         public EPlanTreeItem topGroup { get; set; }
         public EPlanGroup(EPlanTreeItem topGroup) {
            this.topGroup = topGroup;
         }

         public Dictionary<MDPartsDatabaseItem.Enums.ProductGroup, EPlanTreeItem> productGroupMap = new Dictionary<MDPartsDatabaseItem.Enums.ProductGroup, EPlanTreeItem>();
      }



      private void Async_SyncErpCode(object sender, DoWorkEventArgs e) {
         KUtil.Log("开始执行：同步ERP编码");
         duplicateOrderNrBeans.Clear();
         bgWorker_SyncErpCode.Progress("查询EPLAN数据...", 0);
         MDPart[] parts = EplanUtil.QueryParts(mdPartsDatabase, "");
            int len = parts == null ? 0 : parts.Length;

           // MessageBox.Show(len + "");
            KUtil.Log("查询结果数量：" + len);
         if (len == 0) {
            return;
         }
         Dictionary<string, string> orderNr_itemId = new Dictionary<string, string>();
         for (int i = 0; i < len; i++) {
            if (bgWorker_SyncErpCode.IsCancel()) {
               e.Cancel = true;
               break;
            }
            MDPart part = parts[i];
            //string orderNr = KUtil.RemoveSpace(EplanUtil.GetMDPropValue(part.Properties.ARTICLE_PARTNR));
            //20241120 以EPLAN的ERP编码作为与TC的唯一识别；
            string orderNr = KUtil.RemoveSpace(EplanUtil.GetMDPropValue(part.Properties.ARTICLE_ERPNR));
                //MessageBox.Show(orderNr);
                KUtil.Log((i + 1) + ". 检查部件：" + part.PartNr + "|" + orderNr);
            bgWorker_SyncErpCode.Progress("同步数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            if (!KUtil.IsEmpty(orderNr)) {
               string itemId = "";
               if (orderNr_itemId.ContainsKey(orderNr)) {
                  itemId = orderNr_itemId[orderNr];
               }
               else {
                  ModelObject[] revs= TCUtil.Query_LatestRevByOrderNr(orderNr);
                  int revCnt = revs == null ? 0 : revs.Length;

                      // MessageBox.Show(revCnt+"");
                        if (revCnt==1) {
                     Teamcenter.Soa.Client.Model.Strong.ItemRevision rev = revs[0] as Teamcenter.Soa.Client.Model.Strong.ItemRevision;
                     if (rev != null) {
                        ModelObject[] mos = TCUtil.Refresh(rev);
                        TCUtil.GetProperties(false, mos, "item_id");
                        itemId = rev.Item_id;
                     }
                  }
                  else {
                     string manufacturer = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_MANUFACTURER).Trim();
                     DuplicateOrderNrBean duplicate = new DuplicateOrderNrBean() { orderNr=orderNr,partNr= part.PartNr,manufacturer=manufacturer};
                     if (revCnt == 0) {
                        duplicate.reason = "TC中不存在物料";
                     }
                     duplicateOrderNrBeans.Add(duplicate);
                  }
                  orderNr_itemId.Add(orderNr, itemId);
               }
               KUtil.Log(">> 设置ERPNumber = " + itemId);
               //写入ERPNumber
               MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
               part.Properties.ARTICLE_ORDERNR = itemId;
               if (!KUtil.IsEmpty(itemId)) {
                  KUtil.Log(">> 设置为已同步");
                  part.Properties.ARTICLE_CERTIFICATE_ATEX = "已同步";
               }
               trans.Commit();
               trans.Dispose();
            }
         }
         KUtil.Log("执行结束");
         if (duplicateOrderNrBeans.Count > 0) {
            ExportDuplicate(duplicateOrderNrBeans);
         }
         else {
            KUtil.DispatcherShow(this, "同步完成");
         }
      }

      public const string EXPORT_FILE_NAME = "TC存在重复的订单号";
      public const string EXPORT_FILE_EXT = "xlsx";

      private void ExportDuplicate(List<DuplicateOrderNrBean> duplicateOrderNrBeans) {
         int rowCnt = duplicateOrderNrBeans.Count;
         if (rowCnt == 0) {
            return;
         }
         string targetPath = null;
         this.Dispatcher.Invoke(new Action(delegate {
            using (var fbd = new FolderBrowserDialog()) {
               fbd.Description = "导出完成，TC中存在重复订单号，选择文件导出位置";
               DialogResult result = fbd.ShowDialog();
               if (result == System.Windows.Forms.DialogResult.OK) {
                  targetPath = fbd.SelectedPath;
               }
            }
         }));
         if (string.IsNullOrWhiteSpace(targetPath)) {
            return;
         }
         KUtil.Log("导出重复订单号...");
         KUtil.Log("导出路径：" + targetPath);
         string filePath = KUtil.GetFilePath(targetPath, EXPORT_FILE_NAME, EXPORT_FILE_EXT);
         KUtil.Log("导出文件：" + filePath);
         Microsoft.Office.Interop.Excel.Application xlApp = new Microsoft.Office.Interop.Excel.Application();
         if (xlApp == null) {
            KUtil.DispatcherShow(this, "Excel 未正确安装");
            return;
         }
         Microsoft.Office.Interop.Excel.Workbook xlWorkBook;
         Microsoft.Office.Interop.Excel.Worksheet xlWorkSheet;
         object misValue = System.Reflection.Missing.Value;
         xlWorkBook = xlApp.Workbooks.Add(misValue);
         xlWorkSheet = (Microsoft.Office.Interop.Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);

         xlWorkSheet.Cells[1, 1] = "订货号";
         xlWorkSheet.Cells[1, 2] = "部件号";
         xlWorkSheet.Cells[1, 3] = "制造商";
         xlWorkSheet.Cells[1, 4] = "问题原因";

         for (int i = 0; i < rowCnt; i++) {
            int r = i + 2;
            DuplicateOrderNrBean bean = duplicateOrderNrBeans[i];
            xlWorkSheet.Cells[r, 1] = bean.orderNr;
            xlWorkSheet.Cells[r, 2] = bean.partNr;
            xlWorkSheet.Cells[r, 3] = bean.manufacturer;
            xlWorkSheet.Cells[r, 4] = bean.reason;
         }

         //Here saving the file in xlsx
         xlWorkBook.SaveAs(filePath, Microsoft.Office.Interop.Excel.XlFileFormat.xlOpenXMLWorkbook, misValue,
         misValue, misValue, misValue, Microsoft.Office.Interop.Excel.XlSaveAsAccessMode.xlExclusive, misValue, misValue, misValue, misValue, misValue);
         xlWorkBook.Close(true, misValue, misValue);
         xlApp.Quit();
         Marshal.ReleaseComObject(xlWorkSheet);
         Marshal.ReleaseComObject(xlWorkBook);
         Marshal.ReleaseComObject(xlApp);
         KUtil.DispatcherShow(this,"导出完成");
      }

      private void Async_UploadPartsDB(object sender, DoWorkEventArgs e) {
         bgWorker_UploadPartsDB.Progress("准备上传EPLAN数据...", 0);
         string fmsHome = Environment.GetEnvironmentVariable("FMS_HOME");
         string zipFile = fmsHome + "\\EPlan\\" + "EPLAN_PARTS.zip";
         string eplanDataFolderPath = KUtil.GetConfigValue(KConfigure.EPLAN_DATA_SECTION, KConfigure.EPLAN_DATA_FOLDER);
         string skipFolders = KUtil.GetConfigValue(KConfigure.EPLAN_DATA_SECTION, KConfigure.EPLAN_DATA_SKIP_FOLDER);
         string dsUid = KUtil.GetConfigValue(KConfigure.EPLAN_DATA_SECTION, KConfigure.EPLAN_DATASET_UID);
         if (KUtil.IsEmpty(eplanDataFolderPath)) {
            throw new Exception("未配置EPLAN数据文件夹");
         }
         if (KUtil.IsEmpty(dsUid)) {
            throw new Exception("未配置TC数据集UID");
         }
         if (!System.IO.Directory.Exists(eplanDataFolderPath)) {
            throw new Exception("EPLAN数据文件夹不存在，请检查配置：" + eplanDataFolderPath);
         }
         KUtil.Log("准备上传EPLAN数据文件夹：" + eplanDataFolderPath);
         ModelObject mo = TCUtil.StringToComponent(dsUid);
         if (mo == null) {
            throw new Exception("未查询到数据集 uid = " + dsUid + "，请检查配置");
         }
         ModelObject[] mos = TCUtil.Refresh(mo);
         TCUtil.GetProperties(false, mos, "object_string");
         string dsName = mo.GetPropertyDisplayableValue("object_string");
         KUtil.Log("找到数据集：" + dsName);
         if (!TCUtil.IsType(mo.SoaType, "Zip")) {
            throw new Exception("配置的数据集<" + dsName + ">不是Zip数据集，uid = " + dsUid);
         }
         this.bgWorker_UploadPartsDB.Progress("压缩目录...", 30);
         if (!KUtil.ZipDirectory(eplanDataFolderPath, zipFile, null, skipFolders)) {
            throw new Exception("压缩EPLAN部件库失败");
         }
         KUtil.Log("压缩完成");
         this.bgWorker_UploadPartsDB.Progress("上传文件...", 70);
         TCUtil.UploadFile((Teamcenter.Soa.Client.Model.Strong.Dataset)mo, zipFile, "ZIPFILE");
         KUtil.Log("上传成功");
         this.Dispatcher.Invoke(new Action(delegate {
            MessageBox.Show(this, "上传成功");
         }));
      }

      private void Async_Revise(object sender, DoWorkEventArgs e) {
         List<KPartSyncDataRow> reviseList = e.Argument as List<KPartSyncDataRow>;
         if (reviseList.Count == 0) {
            return;
         }
         bgWorker_Revise.Progress("正在升版...", 0);
         int len = reviseList.Count;
         for (int i = 0; i < len; i++) {
            if (bgWorker_Revise.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Revise.Progress("正在升版...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            KPartSyncDataRow bean = reviseList[i];
            Teamcenter.Soa.Client.Model.Strong.ItemRevision newRev = TCUtil.Revise(bean.rev);
            if (newRev == null) {
               throw new Exception("对象升版失败：" + bean.tc_itemid);
            }
            Teamcenter.Soa.Client.Model.ModelObject[] mo = TCUtil.Refresh(newRev);
            TCUtil.GetProperties(false, mo, "item_revision_id");
            MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
            bean.part.Properties.ARTICLE_CERTIFICATE_ATEX = "";
            trans.Commit();
            trans.Dispose();
            this.Dispatcher.Invoke(new Action(delegate {
               bean.tc_revid = newRev.Item_revision_id;
               bean.tc_releasestatus = NOT_RELEASEED;
               bean.sync_status = NOT_SYNCED;
               bean.rev = newRev;
               bean.tc_desc = TCUtil.GetRevConfigProp(newRev, KUtil.GetConfigValue(KConfigure.UI_SOME_SECTION, KConfigure.UI_PROP_DESC));
               bean.tc_manufacturer = TCUtil.GetRevConfigProp(newRev, KUtil.GetConfigValue(KConfigure.UI_SOME_SECTION, KConfigure.UI_PROP_MANUFACTURER));
               table_Sync_To_TC.Items.Refresh();
            }));
         }
      }

      private void Async_TC_to_EPlan(object sender, DoWorkEventArgs e) {
         sync_Success = 0;
         this.Dispatcher.Invoke(new Action(delegate {
            errData.Clear();
         }));
         bgWorker_TC_to_EPlan.Progress("执行中...", 0);
         int len = 0;
         this.Dispatcher.Invoke(new Action(delegate {
            len = ePlanToTCData.Count;
         }));
         for (int i = 0; i < len; i++) {
            if (bgWorker_TC_to_EPlan.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_TC_to_EPlan.Progress("执行中...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            KPartSyncDataRow bean = ePlanToTCData[i];
            if (bean.rev == null) {
               continue;
            }
            string errMsg = null;
            try {
               errMsg = Item_to_EPlan(bean);
            }
            catch (System.Exception ex) {
               KUtil.LogErr(ex);
               errMsg = ex.Message;
            }
            if (KUtil.IsEmpty(errMsg)) {
               sync_Success++;
            }
            else {
               if (!"已同步".Equals(errMsg)) {
                  this.Dispatcher.Invoke(new Action(delegate {
                     errData.Add(GetSyncResultBean(bean,errMsg));
                  }));
               }
            }
         }
      }

      private void Async_EPlan_to_TC(object sender, DoWorkEventArgs e) {
         sync_Success = 0;
         this.Dispatcher.Invoke(new Action(delegate {
            errData.Clear();
         }));
         bgWorker_EPlan_to_TC.Progress("执行中...", 0);
         int len = 0;
         this.Dispatcher.Invoke(new Action(delegate {
            len = ePlanToTCData.Count;
         }));
         for (int i = 0; i < len; i++) {
            if (bgWorker_EPlan_to_TC.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_EPlan_to_TC.Progress("执行中...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            KPartSyncDataRow bean = ePlanToTCData[i];
            if (bean.part == null) {
               continue;
            }
            string errMsg = null;
            try {
               errMsg = Part_to_TC(bean);
            }
            catch (System.Exception ex) {
               KUtil.LogErr(ex);
               errMsg = ex.Message;
            }
            if (KUtil.IsEmpty(errMsg)) {
               sync_Success++;
            }
            else {
               if (!"已同步".Equals(errMsg)) {
                  this.Dispatcher.Invoke(new Action(delegate {
                     string jldw = "";
                     string desc_cn = "";
                     string desc_en = "";
                     if (bean.part != null) {
                        jldw = EplanUtil.GetMDPropValue(bean.part.Properties.ARTICLE_QUANTITYUNIT, Eplan.EplApi.Base.ISOCode.Language.L___);
                        desc_cn = EplanUtil.GetMDPropValue(bean.part.Properties.ARTICLE_NOTE, EplanUtil.Language_CN);
                        desc_en = EplanUtil.GetMDPropValue(bean.part.Properties.ARTICLE_NOTE, EplanUtil.Language);
                     }
                     errData.Add(new SyncResult(bean) { partNr = bean.eplan_partno, orderNr = bean.eplan_orderno, name = bean.eplan_name, jldw = jldw, desc_cn = desc_cn, desc_en = desc_en, reason = errMsg });
                  }));
               }
            }
         }
         //this.Dispatcher.Invoke(new Action(delegate{
         //   new PartSyncResult(this, sync_Success, ePlanToTCData.Count - sync_Success - errData.Count, errData).ShowDialog();
         //}));
      }

      private void bgWorker_EPlan_to_TC_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
         if (e.Error == null) {
            new PartSyncResult(mdPartsDatabase, this, sync_Success, ePlanToTCData.Count - sync_Success - errData.Count, errData).ShowDialog();
            this.table_Sync_To_TC.Items.Refresh();
            //else {
            //   MessageBox.Show(parent, "操作完成");
            //}
         }
      }

      private String Item_to_EPlan(KPartSyncDataRow bean) {
         Teamcenter.Soa.Client.Model.Strong.ItemRevision rev = bean.rev;
         MDPart part = bean.part;
         bool isNew = false;
         if (part == null) {
            string orderNrProp = KUtil.GetConfigValue(KConfigure.PART_SYNC_SECTION, KConfigure.PART_SYNC_OrderNr_TC);
            if (KUtil.IsEmpty(orderNrProp)) {
               throw new Exception("未配置订货号在TC中的属性");
            }
            string orderNr = KUtil.RemoveSpace( TCUtil.GetRevConfigProp(bean.rev, orderNrProp));

            string partNr = "";
            this.Dispatcher.Invoke(new Action(delegate {
               NewPartNr newPartNrDialog = new NewPartNr(this, orderNr);
               newPartNrDialog.ShowDialog();
               partNr = newPartNrDialog.partNr;
            }));
            if (KUtil.IsEmpty(partNr)) {
               return "部件不存在";
            }
            KUtil.Log("新建部件："+partNr);
            part = EplanUtil.NewPart(mdPartsDatabase, rev, partNr);
            if (part == null) {
               throw new Exception("新建Part失败："+partNr);
            }
            //写入订货号
            isNew = true;
            MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
            part.Properties.ARTICLE_PARTNR = orderNr;
            trans.Commit();
            trans.Dispose();
            bean.part = part;
         }
         //同步属性到EPlan
         KUtil.Sync_Property_to_EPlan(mdPartsDatabase, rev, bean.part);
         if (isNew) {
            MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
            bean.part.Properties.ARTICLE_ERPNR = rev.Item_id;
            bean.part.Properties.ARTICLE_CERTIFICATE_ATEX = "已同步";
            trans.Commit();
            trans.Dispose();
         }
         string eplan_partno = EplanUtil.GetMDPropValue(part.PartNr);
         string eplan_orderno = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_ORDERNR);
         string erpNr = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_ERPNR);
         string manufacturer = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_MANUFACTURER).Trim();
         string eplan_name = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_DESCR1,EplanUtil.Language_CN);
         string eplan_desc = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_NOTE,EplanUtil.Language_CN);
         this.Dispatcher.Invoke(new Action(delegate {
            bean.eplan_orderno = rev.Item_id;
            bean.eplan_partno = eplan_partno;
            bean.eplan_erpno = erpNr;
            bean.eplan_name = eplan_name;
            bean.eplan_desc = eplan_desc;
            if (isNew) {
               bean.sync_status = "已同步";
            }
            table_Sync_To_TC.Items.Refresh();
         }));
         return "";
      }

      private bool checkOrderNr(KPartSyncDataRow bean) {
         string orderNr = bean.eplan_orderno == null ? "" : bean.eplan_orderno;
         foreach(KPartSyncDataRow r in ePlanToTCData) {
            if (orderNr.Equals(r.eplan_orderno) && !bean.Equals(r)) {//订货号重复行
               return false;
            }
         }
         return true;
      }

      private string Part_to_TC(KPartSyncDataRow bean) {
         if (bean.part == null) {
            return "部件不存在";
         }
         if (!checkOrderNr(bean)) {
            return "订货号相同";
         }
         string errMsg = null;
         string releaseStatus = bean.tc_releasestatus;
         string syncStatus = bean.sync_status;
         Teamcenter.Soa.Client.Model.Strong.ItemRevision rev = null;

         switch (syncStatus) {
            case NOT_SYNCED:
               if (NOT_RELEASEED.Equals(releaseStatus)) {
                  //通过item获取对象
                  rev = TCUtil.Query_LatestRev(bean.tc_itemid);
                  if (rev == null) {
                     errMsg = "未查询到对象：" + bean.tc_itemid;
                  }
               }
               else {
                  //失败：未升版
                  errMsg = "未升版";
               }
               break;
            case "新增":
               errMsg = "请在TC中进行元器件创建";
               //新建对象 反写ID
               //string tcItemType = KUtil.GetConfigValue(KConfigure.PART_SYNC_SECTION, KConfigure.PART_SYNC_TC_ITEM_TYPE);
               //if (KUtil.IsEmpty(tcItemType)) {
               //   throw new Exception("未配置TC数据类型");
               //}
               //rev = TCUtil.CreateNewRev(tcItemType);
               //if (rev == null) {
               //   errMsg = "新建对象失败";
               //}
               break;
            case SAP_NEED_ID:
               //失败：
               errMsg = SAP_NEED_ID;
               break;
            case "已同步":
               if (!NOT_RELEASEED.Equals(releaseStatus)) {
                  return "未升版";
               }
               if (NOT_RELEASEED.Equals(releaseStatus)) {
                  //通过item获取对象
                  rev = TCUtil.Query_LatestRev(bean.tc_itemid);
                  if (rev == null) {
                     errMsg = "未查询到对象：" + bean.tc_itemid;
                  }
               }
               else {
                  //失败：未升版
                  errMsg = "未升版";
               }
               break;
               //return "已同步";
            case "申请中":
               return "申请中";
            default:
               //失败：未知状态
               errMsg = "未知同步状态：" + syncStatus;
               break;
         }
         if (KUtil.IsEmpty(errMsg)) {
            if (rev == null) {
               errMsg = "获取TC对象异常";
            }
            else {
               {
                  string ordernr = bean.part.Properties.ARTICLE_PARTNR;
                  string ordernr2 = KUtil.RemoveSpace(ordernr);
                  if (ordernr != null && !ordernr.Equals(ordernr2)) {
                     MDPartsDatabaseTransaction trans1 = mdPartsDatabase.CreateTransaction();
                     KUtil.Log("订货号去空格：" + ordernr + " -> " + ordernr2);
                     bean.part.Properties.ARTICLE_PARTNR = ordernr2;
                     trans1.Commit();
                     trans1.Dispose();
                  }
               }
               //属性同步 发送分类
               KUtil.Sync_Property_to_TC(rev, bean.part);
               Teamcenter.Soa.Client.Model.ModelObject[] mo = TCUtil.Refresh(rev);
               TCUtil.GetProperties(false, mo, "item_id", "item_revision_id", "object_name");
               MDPartsDatabaseTransaction trans = mdPartsDatabase.CreateTransaction();
               //EPLAN测试问题反馈-20241217 5.EPLAN同步到TC的属性对应关系有问题，修改了EPLAN中的属性
               //bean.part.Properties.ARTICLE_ERPNR = rev.Item_id;
               bean.part.Properties.ARTICLE_ORDERNR = rev.Item_id;
               bean.part.Properties.ARTICLE_CERTIFICATE_ATEX = "已同步";
               trans.Commit();
               trans.Dispose();
               this.Dispatcher.Invoke(new Action(delegate {
                   //bean.eplan_orderno = EplanUtil.GetMDPropValue(bean.part.Properties.ARTICLE_PARTNR);
                   bean.eplan_orderno = rev.Item_id;
                   //bean.eplan_erpno = rev.Item_id;
                   bean.tc_itemid = rev.Item_id;
                  bean.tc_revid = rev.Item_revision_id;
                  bean.tc_name = rev.Object_name;
                  bean.sync_status = "已同步";
                  bean.tc_desc = TCUtil.GetRevConfigProp(rev, KUtil.GetConfigValue(KConfigure.UI_SOME_SECTION, KConfigure.UI_PROP_DESC));
                  bean.tc_manufacturer = TCUtil.GetRevConfigProp(rev, KUtil.GetConfigValue(KConfigure.UI_SOME_SECTION, KConfigure.UI_PROP_MANUFACTURER));
                  bean.rev = rev;
                  table_Sync_To_TC.Items.Refresh();
               }));
            }
         }
         return errMsg;
      }





      private void Async_QueryTCParts(object sender, DoWorkEventArgs e) 
      { 
         this.Dispatcher.Invoke(new Action(delegate {
            ePlanToTCData.Clear();
         }));
         string partNr = "";
         string itemId = "";
         this.Dispatcher.Invoke(new Action(delegate {
            partNr = tb_PartNr.Text;
            itemId = tb_ERPNr.Text;
         }));
         string queryName = KUtil.GetConfigValue(KConfigure.PART_QUERY_SECTION, KConfigure.PART_QUERY_NAME);
         string itemField = KUtil.GetConfigValue(KConfigure.PART_QUERY_SECTION, KConfigure.PART_QUERY_ITEM_ID);
         string partField = KUtil.GetConfigValue(KConfigure.PART_QUERY_SECTION, KConfigure.PART_QUERY_ORDERNR);
         if (KUtil.IsEmpty(queryName) || KUtil.IsEmpty(itemField) || KUtil.IsEmpty(partField)) {
            throw new Exception("TC部件查询配置缺失，请检查设置");
         }
         string orderNrProp = KUtil.GetConfigValue(KConfigure.PART_SYNC_SECTION, KConfigure.PART_SYNC_OrderNr_TC);
         if (KUtil.IsEmpty(orderNrProp)) {
            throw new Exception("未配置订货号在TC中的属性");
         }
         Dictionary<string, string> fields = new Dictionary<string, string>();
         if (!KUtil.IsEmpty(itemId)) {
            fields.Add(itemField, itemId);
         }
         if (!KUtil.IsEmpty(partNr)) {
            fields.Add(partField, partNr);
         }
         if (fields.Count == 0) {
            KUtil.DispatcherShow(this, "请输入查询条件");
            //MessageBox.Show(this, "请输入查询条件"); 
            return;
         }
         KUtil.Log("查询部件：PartNR = " + partNr + ", ErpNR = " + itemId);
         bgWorker_Query_TC.Progress("查询中...", 0);
         ModelObject[] unsyncItems = TCUtil.query(queryName, fields);
         int len = unsyncItems == null ? 0 : unsyncItems.Length;
           // MessageBox.Show(len + " 1");
            KUtil.Log("查询结果数量：" + len);
         for (int i = 0; i < len; i++) {
            if (bgWorker_Query_TC.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Query_TC.Progress("加载数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            ModelObject rev = unsyncItems[i];
            ModelObject[] mo = TCUtil.Refresh(rev);
            TCUtil.GetProperties(false, mo, "object_string");
            if (!TCUtil.IsType(rev.SoaType, "ItemRevision")) {
               throw new Exception("获取配置属性失败，对象不是版本类型：" + rev.GetPropertyDisplayableValue("object_string"));
            }
            Add_Sync_Data((Teamcenter.Soa.Client.Model.Strong.ItemRevision)rev, orderNrProp);
         }
      }

      private void Async_QueryParts(object sender, DoWorkEventArgs e) {
         
         this.Dispatcher.Invoke(new Action(delegate {
            ePlanToTCData.Clear();
         }));
         string partNr = "";
         string erpNr = "";
         this.Dispatcher.Invoke(new Action(delegate {
            partNr = tb_PartNr.Text;
            erpNr = tb_ERPNr.Text;
         }));
         KUtil.Log("查询部件：OrderNr = " + partNr + ", ErpNR = " + erpNr);
         bgWorker_Query.Progress("查询中...", 0);
         MDPart[] unsyncParts = EplanUtil.QueryParts(mdPartsDatabase, partNr, erpNr);
         int len = unsyncParts == null ? 0 : unsyncParts.Length;
         KUtil.Log("查询结果数量：" + len);
         for (int i = 0; i < len; i++) {
            if (bgWorker_Query.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Query.Progress("加载数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            Add_Sync_Data(unsyncParts[i], false);
         }
      }

      public static bool NeedApply(KPartSyncDataRow bean) {
         return bean != null && SAP_NEED_ID.Equals(bean.sync_status);
      }

      public static SyncResult GetSyncResultBean(KPartSyncDataRow bean, string errMsg) {
         string jldw = "";
         string desc_cn = "";
         string desc_en = "";
         if (bean.part != null) {
            jldw = EplanUtil.GetMDPropValue(bean.part.Properties.ARTICLE_QUANTITYUNIT, Eplan.EplApi.Base.ISOCode.Language.L___);
            desc_cn = EplanUtil.GetMDPropValue(bean.part.Properties.ARTICLE_NOTE, EplanUtil.Language_CN);
            desc_en = EplanUtil.GetMDPropValue(bean.part.Properties.ARTICLE_NOTE, EplanUtil.Language);
         }
         return new SyncResult(bean) { partNr = bean.eplan_partno, orderNr = bean.eplan_orderno, name = bean.eplan_name, jldw = jldw, desc_cn = desc_cn, desc_en = desc_en, reason = errMsg };
      }

      private void Async_Apply(object sender, DoWorkEventArgs e) {
         System.Collections.IList selectedItems = null;
         bgWorker_Apply.Progress("检查数据...", 0);
         this.Dispatcher.Invoke(new Action(delegate {
            selectedItems = table_Sync_To_TC.SelectedItems;
         }));
         if (selectedItems == null || selectedItems.Count == 0) {
            KUtil.DispatcherShow(this, "请选择要发起编码申请的部件");
            return;
         }
         KUtil.Log("发起编码申请...");
         bool descEmpty = false;
         List<SyncResult> applyData = new List<SyncResult>();
         for(int i = 0; i < selectedItems.Count; i++) {
            KPartSyncDataRow dataRow = (KPartSyncDataRow)selectedItems[i];
            if (!NeedApply(dataRow)) {
               continue;
            }
            SyncResult bean = GetSyncResultBean(dataRow, SAP_NEED_ID);
            if (KUtil.IsEmpty(bean.desc_en)) {
               KUtil.Log("描述缺失：" + bean.partNr);
               descEmpty = true;
               //break;
            }
            else {
               applyData.Add(bean);
            }
         }
         if(descEmpty) {
            KUtil.Log("缺少英文描述，请填写后重新申请");
            KUtil.DispatcherShow(this, "缺少英文描述，请填写后重新申请");
            return;
         }
         bgWorker_Apply.Progress("发起申请...", 0);
         PartSyncResult.DoApply(this, applyData, mdPartsDatabase);
         this.Dispatcher.Invoke(new Action(delegate {
            this.table_Sync_To_TC.Items.Refresh();
         }));
      }

      private void Async_AddAllUnsyncedParts(object sender, DoWorkEventArgs e) {
         string partNr = "";
         string erpNr = "";
         this.Dispatcher.Invoke(new Action(delegate {
            partNr = tb_PartNr.Text;
            erpNr = tb_ERPNr.Text;
         }));
         KUtil.Log("查询未同步部件：OrderNr = " + partNr + ", ErpNR = " + erpNr);
         bgWorker_AddAll.Progress("查询中...", 0);
         List<MDPart> unsyncParts = EplanUtil.GetUnsyncedParts(mdPartsDatabase, partNr, erpNr);
         int len = unsyncParts == null ? 0 : unsyncParts.Count;
         KUtil.Log("查询全部未同步部件数量：" + len);
         for (int i = 0; i < len; i++) {
            if (bgWorker_AddAll.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_AddAll.Progress("加载数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            Add_Sync_Data(unsyncParts[i], false);
         }
      }

      private void Async_LoadParts(object sender, DoWorkEventArgs e) {
         EPlanTreeItem parent = (EPlanTreeItem)e.Argument;
         if (parent != null) {
            Cycle_Home(parent, e);
            return;
         }
         //TreeViewItem node_home = null;
         bgWorker_Parts.Progress("加载数据...", 0);
         EPlanTreeItem tree_home = null;
         this.Dispatcher.Invoke(new Action(delegate {
            tree_home = new EPlanTreeItem("Parts");
            tree_Parts.Items.Add(tree_home);
         }));
         /*int len = allParts.Length;
         for (int i = 0; i < len; i++) {
            if (bgWorkder_Parts.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorkder_Parts.Progress("加载数据...( "+(i+1)+" / "+len+" )", (i + 1) * 100 / len);
            MDPart p = allParts[i];
            EPlanTreeItem groupItem = FindTreeItem(p.GenericProductGroup, p.ProductGroup, tree_home); 
            if (groupItem == null) {
               throw new Exception("获取组节点异常");
            }
            this.Dispatcher.Invoke(new Action(delegate {
               groupItem.Items.Add(new EPlanTreeItem(p));
            }));
         }
         this.Dispatcher.Invoke(new Action(delegate {
            foreach (EPlanGroup g in topGroupMap.Values) {
               g.topGroup.Items.SortDescriptions.Add(new SortDescription("Header", ListSortDirection.Ascending));
               g.topGroup.Items.Refresh();
            }
         }));*/
         //加载TOPGROUP
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Electric, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Mechanic, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Fluid, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Process, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Invaild, tree_home);
         Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup.Undefined, tree_home);
         this.Dispatcher.Invoke(new Action(delegate {
            tree_home.IsExpanded = true;
         }));
      }

      private EPlanTreeItem FindTreeItem(MDPartsDatabaseItem.Enums.ProductTopGroup topGroup, MDPartsDatabaseItem.Enums.ProductGroup group, EPlanTreeItem root) {
         EPlanGroup ePlanGroup = null;
         if (topGroupMap.ContainsKey(topGroup)) {
            ePlanGroup = topGroupMap[topGroup];
         }
         else {
            this.Dispatcher.Invoke(new Action(delegate {
               //string topGroupName = MDPartsDatabaseItem.GetProductTopGroupName(topGroup);
               EPlanTreeItem topGroupItem = new EPlanTreeItem(topGroup);
               ePlanGroup = new EPlanGroup(topGroupItem);
               root.Items.Add(topGroupItem);
               topGroupMap.Add(topGroup, ePlanGroup);
            }));
         }
         if (ePlanGroup == null) { return null; }
         if (ePlanGroup.productGroupMap.ContainsKey(group)) {
            return ePlanGroup.productGroupMap[group];
         }
         else {
            EPlanTreeItem groupItem = null;
            this.Dispatcher.Invoke(new Action(delegate {
               //string groupName = MDPartsDatabaseItem.GetProductGroupName(group);
               groupItem = new EPlanTreeItem(topGroup,group);
               ePlanGroup.topGroup.Items.Add(groupItem);
               ePlanGroup.productGroupMap.Add(group, groupItem);
            }));
            return groupItem;
         }
      }

      private void Init_TopGroup(MDPartsDatabaseItem.Enums.ProductTopGroup topGroup, EPlanTreeItem tree_home) {
         //if (!EplanUtil.TopGroupHasPart(topGroup)) {
         //   return;
         //}
         //string topGroupName = MDPartsDatabaseItem.GetProductTopGroupName(topGroup);
         EPlanTreeItem tree_TopGroup = null;
         this.Dispatcher.Invoke(new Action(delegate {
            tree_TopGroup = new EPlanTreeItem(topGroup);
            //KUtil.Log(tree_TopGroup.Header.ToString());
            tree_home.Items.Add(tree_TopGroup);
         }));
         //加载Group
         MDPartsDatabaseItem.Enums.ProductGroup[] groups = MDPartsDatabaseItem.GetAvailableProductGroups(topGroup);
         for (int i = 0; i < groups.Length; i++) {
            MDPartsDatabaseItem.Enums.ProductGroup group = groups[i];
            //if (!EplanUtil.GroupHasPart(topGroup, group)) {
            //   continue;
            //}
            this.Dispatcher.Invoke(new Action(delegate {
               EPlanTreeItem tree_Group = new EPlanTreeItem(topGroup,group);
               //KUtil.Log(">> " + tree_Group.Header.ToString());
               tree_TopGroup.Items.Add(tree_Group);
               tree_Group.Items.Add(new EPlanTreeItem());//展开加载标记
            }));
         }
         this.Dispatcher.Invoke(new Action(delegate {
            tree_TopGroup.Items.SortDescriptions.Add(new SortDescription("Header", ListSortDirection.Ascending));
            tree_TopGroup.Items.Refresh();
         }));
      }

      private void Cycle_Home(EPlanTreeItem treeItem, DoWorkEventArgs e) {
         DateTime t1,t2;
         bool flag = false;
         this.Dispatcher.Invoke(new Action(delegate {
            if (!(treeItem.Items.Count == 1 && ((EPlanTreeItem)treeItem.Items.GetItemAt(0)).isLoadMark)) {
               flag = true;
            }
         }));
         if (flag) { return; }
         int topGroupId = -404;
         int groupId = -404;
         string groupName = "";
         this.Dispatcher.Invoke(new Action(delegate {
            treeItem.Items.Clear();
            EPlanTreeItem topGroupItem = (EPlanTreeItem)treeItem.Parent;
            KUtil.Log("查询：" + topGroupItem.Header + "|" + treeItem.Header);
            topGroupId = topGroupItem.groupId;
            groupId = treeItem.groupId;
            groupName = treeItem.Header.ToString();
         }));
         if (topGroupId == -404 && groupId == -404) {
            return;
         }
         bgWorker_Parts.Progress("查询中...", 0);


         t1 = DateTime.Now;
         MDPart[] parts = EplanUtil.GetParts(mdPartsDatabase, topGroupId, groupId);
         t2 = DateTime.Now;
         //KUtil.DispatcherShow(this, "查询耗时：" + (t2 - t1).TotalSeconds + "毫秒");
         KUtil.Log("查询耗时：" + (t2 - t1).TotalSeconds + "秒");
         int len = parts == null ? 0 : parts.Length;
         for (int i = 0; i < len; i++) {
            if (bgWorker_Parts.IsCancel()) {
               e.Cancel = true;
               return;
            }
            bgWorker_Parts.Progress("加载数据...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
            this.Dispatcher.Invoke(new Action(delegate {
               treeItem.Items.Add(new EPlanTreeItem(parts[i], groupName));
            }));
         }



         //string group = treeItem.Header as string;
         //MDPartsDatabaseItem.GetAvailableProductGroups

         //ModelObject parent = treeItem.mo;
         //ModelObject[] children = null;
         ////var t = parent.GetType();
         //SoaType soaType = parent.SoaType;
         //ModelObject[] mo = TCUtil.Refresh(parent);
         //if (TCUtil.IsType(soaType, "Folder")) {
         //   TCUtil.GetProperties(false, mo, "contents");
         //   children = ((Folder)parent).Contents;
         //}
         //else if (TCUtil.IsType(soaType, "Item") || TCUtil.IsType(soaType, "ItemRevision")) {
         //   children = TCUtil.GetChildFromPref(parent);
         //}
         //else if (TCUtil.IsType(soaType, "Dataset")) {
         //   children = null;
         //}
         //else {
         //   return;
         //}
         //if (children == null) {
         //   return;
         //}
         //if (bgWorker_Query.IsCancel()) {
         //   e.Cancel = true;
         //   return;
         //}
         //ItemCollection node_children = null;
         //this.Dispatcher.Invoke(new Action(delegate {
         //   node_children = treeItem.Items;
         //}));
         //int len = children.Length;
         //for (int i = 0; i < len; i++) {
         //   if (bgWorker_Query.IsCancel()) {
         //      e.Cancel = true;
         //      return;
         //   }
         //   bgWorker_Homer.Progress("加载中...( " + (i + 1) + " / " + len + " )", (i + 1) * 100 / len);
         //   ModelObject c = children[i];
         //   EPlanTreeItem node_child = null;
         //   this.Dispatcher.Invoke(new Action(delegate {
         //      node_child = new EPlanTreeItem(c);
         //      node_children.Add(node_child);
         //      node_child.Items.Add(new EPlanTreeItem(null));
         //   }));
         //}
      }

      private void Window_Loaded(object sender, RoutedEventArgs e) {
         bgWorker_Parts.Start(null,true);
      }

      private void Tree_Parts_Expanded(object sender, RoutedEventArgs e) {
         EPlanTreeItem item = e.OriginalSource as EPlanTreeItem;
         bgWorker_Parts.Start(item,true);
      }

      private void Table_Sync_To_TC_Loaded(object sender, RoutedEventArgs e) {

      }

      /// <summary>
      /// 元器件库添加按钮
      /// </summary>
      /// <param name="sender"></param>
      /// <param name="e"></param>
      private void Add_Button_Click(object sender, RoutedEventArgs e) {
         
         EPlanTreeItem selectedItem = tree_Parts.SelectedItem as EPlanTreeItem;
         if (selectedItem == null) {
            return;
         }
         if(selectedItem.part == null) {
            this.bgWorker_AddGroup.Start(null);
            return;
         }
         try {
            Add_Sync_Data(selectedItem.part, true);
         }
         catch (System.Exception ex) {
            KUtil.LogErr(ex);
            MessageBox.Show(this, "添加数据出错：" + ex.Message);
         }
      }

      private void Async_AddGroup(object sender, DoWorkEventArgs e) {
         EPlanTreeItem selectedItem = null;
         this.Dispatcher.Invoke(new Action(delegate {
            selectedItem = tree_Parts.SelectedItem as EPlanTreeItem;
         }));
         if (selectedItem == null) {
            return;
         }
         if (selectedItem.part == null) {
            ItemCollection items = null;
            this.Dispatcher.Invoke(new Action(delegate {
               items = selectedItem.Items;
            }));
            int len = items==null?0:items.Count;
            for (int i = 0; i < len; i++) {
               if (bgWorker_AddGroup.IsCancel()) {
                  e.Cancel = true;
                  return;
               }
               EPlanTreeItem child = items[i] as EPlanTreeItem;
               //this.Dispatcher.Invoke(new Action(delegate {
               //   child = selectedItem.ItemContainerGenerator.ContainerFromItem(items[i]) as EPlanTreeItem;
               //}));
               if (child == null || child.part == null) {
                  continue;
               }
               bgWorker_AddGroup.Progress("添加数据...( "+(i+1)+" / "+len+" )", (i + 1) * 100 / len);
               Add_Sync_Data(child.part, false);
            }
            return;
         }
         Add_Sync_Data(selectedItem.part, true);
      }

      private KPartSyncDataRow AddDataRow(bool select,Teamcenter.Soa.Client.Model.Strong.ItemRevision tcRev,MDPart part) {
         string partNr = "";
         string orderNr = "";
         string itemID = "";
         string itemRev = "";
         string itemName = "";
         string releaseStatus = "";
         string manufacturer = "";
         string atex = "";
         string eplan_name = "";
         string eplan_desc = "";
         string eplan_erpNo = "";
         if (part != null) {
            partNr = part.PartNr; 
            //orderNr = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_PARTNR);
            orderNr = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_ORDERNR);
            orderNr = KUtil.RemoveSpace(orderNr);
            eplan_erpNo = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_ERPNR);
            manufacturer = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_MANUFACTURER).Trim();
            atex = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_CERTIFICATE_ATEX);
            eplan_name = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_DESCR1,EplanUtil.Language_CN);
            eplan_desc = EplanUtil.GetMDPropValue(part.Properties.ARTICLE_NOTE,EplanUtil.Language_CN);
         }
         if (tcRev != null) {
            Teamcenter.Soa.Client.Model.ModelObject[] mo = TCUtil.Refresh(tcRev);
            TCUtil.GetProperties(false, mo, "item_id", "item_revision_id", "object_name", "release_status_list");
            itemID = tcRev.Item_id;
            itemRev = tcRev.Item_revision_id;
            itemName = tcRev.Object_name;
            Teamcenter.Soa.Client.Model.Strong.ReleaseStatus[] releaseList = tcRev.Release_status_list;
            TCUtil.GetProperties(false, releaseList, "name");
            for (int i = 0; i < releaseList.Length; i++) {
               releaseStatus += releaseList[i].Name;
               if (i != releaseList.Length - 1) {
                  releaseStatus += ", ";
               }
            }
         }
         if (KUtil.IsEmpty(releaseStatus)) {
            releaseStatus = NOT_RELEASEED;
         }
         string syncStatus = GetSyncStatus(partNr,atex, manufacturer, itemID);
         KPartSyncDataRow b = new KPartSyncDataRow();
         b.index = ePlanToTCData.Count + 1;
         b.eplan_orderno = orderNr;
         b.eplan_partno = partNr;
         b.eplan_erpno = eplan_erpNo;
         b.eplan_name = eplan_name;
         b.eplan_desc = eplan_desc;
         b.eplan_manufacturer = manufacturer;
         b.tc_itemid = itemID;
         b.tc_name = itemName;
         b.tc_revid = itemRev;
         b.tc_desc = TCUtil.GetRevConfigProp(tcRev,KUtil.GetConfigValue(KConfigure.UI_SOME_SECTION,KConfigure.UI_PROP_DESC));
         b.tc_manufacturer = TCUtil.GetRevConfigProp(tcRev, KUtil.GetConfigValue(KConfigure.UI_SOME_SECTION, KConfigure.UI_PROP_MANUFACTURER));
         b.tc_releasestatus = releaseStatus;
         b.sync_status = syncStatus;
         b.part = part;
         b.rev = tcRev;
         this.Dispatcher.Invoke(new Action(delegate {
            if (ePlanToTCData.Contains(b)) {
               if (select) {
                  table_Sync_To_TC.SelectedItem = b;
                  table_Sync_To_TC.ScrollIntoView(b);
               }
            }
            else {
               ePlanToTCData.Add(b);
               table_Sync_To_TC.ScrollIntoView(b);
            }
         }));
         return b;
      }

      private void Add_Sync_Data(MDPart part, bool select) {
         string orderNr = KUtil.RemoveSpace(EplanUtil.GetMDPropValue(part.Properties.ARTICLE_ERPNR));
         ModelObject[] tcRevs = TCUtil.Query_LatestRevByOrderNr(orderNr);
         int len = tcRevs == null ? 0 : tcRevs.Length;
         if (len>0) {
            for (int k = 0; k < len; k++) {
               Teamcenter.Soa.Client.Model.Strong.ItemRevision tcRev = tcRevs[k] as Teamcenter.Soa.Client.Model.Strong.ItemRevision;
               if (tcRev == null) {
                  continue;
               }
               AddDataRow(select,tcRev, part);
            }
         }
         else {
            AddDataRow(select,null, part);
         }
      }

      private void Add_Sync_Data(Teamcenter.Soa.Client.Model.Strong.ItemRevision rev, string orderNrConfig) {
         ModelObject[] mo = TCUtil.Refresh(rev);
         TCUtil.GetProperties(false, mo, "item_id", "item_revision_id", "release_status_list", "object_string");
         string orderNr = TCUtil.GetRevConfigProp(rev, orderNrConfig);
         KUtil.Log("查询部件：OrderNr = " + orderNr);
         MDPart[] unsyncParts = EplanUtil.QueryParts2(mdPartsDatabase, orderNr, "");
         int len = unsyncParts == null ? 0 : unsyncParts.Length;
            //MessageBox.Show(len + " 2");
            KUtil.Log("查询结果数量：" + len);
         if (len > 0) {
            for(int k = 0; k < len; k++) {
               AddDataRow(false, rev, unsyncParts[k]);
            }
         }
         else {
            AddDataRow(false, rev, null);
         }
      }

      private string GetSyncStatus(string partNr,string syncStatus, string type, string itemID) {
         if (KUtil.IsEmpty(partNr)) {
            return PART_NOT_EXIST;
         }
         if (!"已同步".Equals(syncStatus)) {
            if (KUtil.IsEmpty(itemID)) {
               return "新增";
               //if (type == null) {
               //   type = "";
               //}
               //type = type.Trim().ToUpper();
               //if ("SIEMENS".Equals(type)||"SIE".Equals(type)) {
               //   if (APPLYING.Equals(syncStatus)){
               //      return syncStatus;
               //   }
               //   return SAP_NEED_ID;
               //}
               //else {
               //   return "新增";
               //}
            }
            else {
               return NOT_SYNCED;
            }
         }
         return syncStatus;
      }

      private void Remove_Button_Click(object sender, RoutedEventArgs e) {
         try {
            System.Collections.IList selectedItems = table_Sync_To_TC.SelectedItems;
            if (selectedItems == null || selectedItems.Count == 0) {
               return;
            }
            while (selectedItems.Count > 0) {
               ePlanToTCData.Remove((KPartSyncDataRow)selectedItems[0]);
               table_Sync_To_TC.Items.Refresh();
            }
            for (int i = 0; i < ePlanToTCData.Count; i++) {
               ePlanToTCData[i].index = (i + 1);
            }
            table_Sync_To_TC.Items.Refresh();
         }
         catch (System.Exception ex) {
            KUtil.LogErr(ex);
            MessageBox.Show(this, ex.Message);
         }
      }

      private void Add_All_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_AddAll.Start(null);
      }

      private void Apply_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_Apply.Start(null);
      }

      private void Query_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_Query.Start(null);
      }

      private void EPlan_to_TC_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_EPlan_to_TC.Start(null);
      }

      private void Close_Button_Click(object sender, RoutedEventArgs e) {
         Close();
      }

      private void Revise_Button_Click(object sender, RoutedEventArgs e) {
         System.Collections.IList selectedItems = table_Sync_To_TC.SelectedItems;
         if (selectedItems == null || selectedItems.Count == 0) {
            return;
         }
         List<KPartSyncDataRow> reviseList = new List<KPartSyncDataRow>();
         for (int i = 0; i < selectedItems.Count; i++) {
            KPartSyncDataRow bean = selectedItems[i] as KPartSyncDataRow;
            if (bean.rev != null) {
               reviseList.Add(bean);
            }
         }
         if (reviseList.Count == 0) {
            MessageBox.Show(this, "没有可升版的数据");
            return;
         }
         bgWorker_Revise.Start(reviseList);
      }

      private void TC_to_EPLAN_Button_Click(object sender, RoutedEventArgs e) {
         this.bgWorker_TC_to_EPlan.Start(null);
      }

      private void TC_Query_Button_Click(object sender, RoutedEventArgs e) {
         bgWorker_Query_TC.Start(null);
      }

      private void Tree_Parts_MouseDoubleClick(object sender, MouseButtonEventArgs e) {
         Add_Button_Click(sender, e);
      }

      private void Upload_PartsDB(object sender, RoutedEventArgs e) {
         bgWorker_UploadPartsDB.Start(null);
      }

      private void SyncErpCode_Button_Click(object sender, RoutedEventArgs e) {
         bgWorker_SyncErpCode.Start(null);
      }

      private void Button_Click(object sender, RoutedEventArgs e) {

      }
   }
}