Пример #1
0
        /// <summary>
        /// 插入包含表数据
        /// </summary>
        /// <param name="newObject"></param>
        /// <param name="newG3e_fid"></param>
        /// <param name="flag">true清空G3E_OWNERFID值,反之 </param>
        private void SetContainTable(ICloneable newObject, long newG3e_fid, bool flag)
        {
            var contain = newObject.Clone() as Contain_n;

            contain.G3E_ID       = CYZCommonFunc.getid();
            contain.G3E_FID      = newG3e_fid;
            contain.G3E_CID      = 1;
            contain.G3E_CNO      = 38;
            contain.EntityState  = EntityState.Insert;
            contain.EntityState2 = EntityState2.Copy;
            contain.SetValue("LTT_ID", (decimal)MapConfig.Instance.LTTID);
            if (flag)
            {
                contain.G3E_OWNERFID = 0;
            }

            DBManager.Instance.Insert(contain);

            var value = newObject as Contain_n;

            switch (contain.G3E_FNO)
            {
            case 141:
                _containDxTableData.Add(contain);
                break;

            case 201:
                _containDgTableData.Add(value.G3E_FID, contain);
                break;
            }
        }
Пример #2
0
        private static void SetContainTable(ICloneable dbEntity, long newG3e_fid, bool flag)
        {
            var contain = dbEntity.Clone() as Contain_n;

            if (contain == null)
            {
                return;
            }
            contain.G3E_FID     = newG3e_fid;
            contain.G3E_ID      = CYZCommonFunc.getid();
            contain.EntityState = EntityState.Insert;
            contain.SetValue("LTT_ID", (decimal)MapConfig.Instance.LTTID);
            DBManager.Instance.Insert(contain);
            if (flag)
            {
                contain.G3E_OWNERFID = 0;
            }

            var value = dbEntity as Contain_n;

            switch (contain.G3E_FNO)
            {
            case 141:
                DBEntityCopy.Instance._containDxTableData.Add(contain);
                break;

            case 201:
                if (value != null)
                {
                    DBEntityCopy.Instance._containDgTableData.Add(value.G3E_FID, contain);
                }
                break;
            }
        }
Пример #3
0
        private long Add_Gg_jx_shbd_pt(long g3efid)
        {
            //增加Gg_jx_shbd_pt表
            var detail = DBManager.Instance.GetEntity <Detailreference_n>(o => o.G3E_FID == FID);
            var t2     = new Gg_jx_shbd_pt
            {
                G3E_DETAILID  = detail.G3E_DETAILID,
                G3E_FNO       = 160,
                G3E_CNO       = 16004,
                G3E_FID       = g3efid,
                G3E_ALIGNMENT = 0,
                G3E_ID        = CYZCommonFunc.getid(),
                G3E_CID       = 1,
                LTT_ID        = MapConfig.Instance.LTTID,
                EntityState   = EntityState.Insert
            };

            if (false == DBManager.Instance.Insert(t2))
            {
                throw new Exception("Add_Gg_jx_shbd_pt: 插入失败!");
            }
            if (detail.DETAIL_USERNAME == null)
            {
                detail.DETAIL_USERNAME = detail.G3E_FID.ToString();
                DBManager.Instance.Update(detail);
            }
            return(t2.G3E_ID);
        }
Пример #4
0
        /// <summary>
        /// 生成新的G3E系列ID
        /// </summary>
        /// <param name="OldG3e_fid"></param>
        /// <param name="OldG3e_id"> </param>
        /// <param name="newObjectId"> </param>
        public void CreateG3EFID(long OldG3e_fid, long OldG3e_id, ObjectId newObjectId)
        {
            var entity = PublicMethod.Instance.GetObject(newObjectId, OpenMode.ForRead);

            if (!_G3EIdMapping.ContainsKey(OldG3e_fid))
            {
                var ed = new ExpandsData
                {
                    newG3e_id   = CYZCommonFunc.getid(),
                    newG3e_fid  = CYZCommonFunc.getid(),
                    oldG3e_id   = OldG3e_id,
                    oldG3e_fid  = OldG3e_fid,
                    newObjectId = newObjectId
                };
                _G3EIdMapping.Add(OldG3e_fid, ed);
            }
            else
            {
                //只存储点符号的对象ID(不存储标注)
                if (entity is BlockReference)
                {
                    var aa = _G3EIdMapping[OldG3e_fid];
                    aa.newObjectId = newObjectId;
                }
            }
        }
Пример #5
0
        private void Add_Gg_jx_shbd_lb(long g3efid)
        {
            //增加Gg_jx_shbd_lb
            var t     = DBManager.Instance.GetEntity <Detailreference_n>(o => o.G3E_FID == FID);
            var shblb = new Gg_jx_shbd_lb
            {
                G3E_ALIGNMENT = 5,
                G3E_ID        = CYZCommonFunc.getid(),
                G3E_FNO       = 160,
                G3E_CNO       = 16005,
                G3E_FID       = g3efid,
                G3E_CID       = 1,
                G3E_DETAILID  = t.G3E_DETAILID,
                LTT_ID        = MapConfig.Instance.LTTID,
                EntityState   = EntityState.Insert
            };

            if (false == DBManager.Instance.Insert(shblb))
            {
                throw new Exception("Add_Gg_jx_shbd_lb: 插入失败!");
            }
            #region
            //GDO_GID
            //G3E_GEOMETRY
            //CD_SSDW
            //LTT_TID
            //LTT_STATUS
            //LTT_DATE
            #endregion
        }
Пример #6
0
        /// <summary>
        /// 新增受电馈线
        /// </summary>
        /// <param name="dbEntity"></param>
        /// <returns>返回G3e_id</returns>
        public static long InsertSDKX(Common_n dbEntity)
        {
            try
            {
                var cid = DBEntityFinder.Instance.GetSdkxCount(dbEntity.G3E_FID);
                cid++;
                var g3eid  = CYZCommonFunc.getid();
                var newEnt = new Gg_pd_sdkx_ac
                {
                    G3E_ID      = g3eid,
                    G3E_FID     = dbEntity.G3E_FID,
                    G3E_FNO     = dbEntity.G3E_FNO,
                    G3E_CID     = cid,
                    G3E_CNO     = 14904,
                    LTT_DATE    = dbEntity.LTT_DATE,
                    LTT_ID      = MapConfig.Instance.LTTID,
                    LTT_STATUS  = dbEntity.LTT_STATUS,
                    LTT_TID     = dbEntity.LTT_TID,
                    SCM_DID     = dbEntity.SCM_DID,
                    GDBDZ       = dbEntity.CD_SSBDZ,
                    KXH         = dbEntity.CD_SSXL,
                    EntityState = EntityState.Insert
                };

                DBManager.Instance.Insert(newEnt);
                return(newEnt.G3E_ID);
            }
            catch (Exception ex)
            {
                LogManager.Instance.Error(ex);
            }
            return(0);
        }
Пример #7
0
 /// <summary>
 /// 添加包含关系
 /// </summary>
 /// <param name="cid"></param>
 /// <param name="dgG3e_fid"></param>
 /// <param name="dxPt"></param>
 public static int AddContain(int cid, long dgG3e_fid, ElectronSymbol dxPt)
 {
     try
     {
         cid++;
         var g3e_id  = CYZCommonFunc.getid();
         var contain = new Contain_n
         {
             G3E_CID      = cid,
             G3E_FNO      = dxPt.G3E_FNO,
             G3E_FID      = dxPt.G3E_FID,
             G3E_CNO      = 38,
             G3E_ID       = g3e_id,
             G3E_OWNERFID = dgG3e_fid,
             G3E_OWNERFNO = 201,
             EntityState  = EntityState.Insert,
             LTT_ID       = MapConfig.Instance.LTTID
         };
         DBManager.Instance.Insert(contain);
     }
     catch (Exception ex)
     {
         LogManager.Instance.Error(ex);
     }
     return(cid);
 }
Пример #8
0
 private IEnumerable <Gg_pd_jlb_n> GetJLB_NS()
 {
     try
     {
         var jlbs   = new List <Gg_pd_jlb_n>();
         var detail = DBManager.Instance.GetEntities <Detailreference_n>(o => o.G3E_FID == detail_fid && o.EntityState != EntityState.Delete).FirstOrDefault();//为空
         if (detail == null)
         {
             var df = new Detailreference_n
             {
                 G3E_CID      = 1,
                 G3E_ID       = detail_id,
                 G3E_CNO      = 35,
                 G3E_FID      = detail_fid,
                 G3E_FNO      = (int)detail_fno,
                 LTT_ID       = MapConfig.Instance.LTTID,
                 EntityState  = EntityState.Insert,
                 G3E_DETAILID = CYZCommonFunc.getid()
             };
             DBManager.Instance.Insert(df);
             return(null);
         }
         var jxjlbs = DBManager.Instance.GetEntities <Gg_jx_jlb_pt>(o => o.G3E_DETAILID == detail.G3E_DETAILID && o.EntityState != EntityState.Delete);
         if (jxjlbs == null)
         {
             return(null);
         }
         foreach (var jlb in jxjlbs)
         {
             jlbs.Add(GetJLB_N(jlb.G3E_FID));
         }
         return(jlbs);
     }
     catch (NotExistException ex)
     {
         if (ex.Message == "Detailreference_n不存在")
         {
             var type     = TypeCache.Instance.GetTypeFromCache(typeof(DBEntity), "Detailreference_n");
             var connectn = ReflectionUtils.CreateObject(new { }, type) as DBEntity;
             DBManager.Instance.Insert(connectn);
             // 插入变压器数据
         }
         else if (ex.Message == "Gg_jx_jlb_pt不存在")
         {
             var type     = TypeCache.Instance.GetTypeFromCache(typeof(DBEntity), "Gg_jx_jlb_pt");
             var connectn = ReflectionUtils.CreateObject(new { }, type) as DBEntity;
             DBManager.Instance.Insert(connectn);
         }
         else
         {
             PublicMethod.Instance.AlertDialog(ex.Message);
         }
         return(null);
     }
     catch (Exception)
     {
         return(null);
     }
 }
Пример #9
0
        /// <summary>
        /// 添加组件表
        /// </summary>
        /// <param name="className"></param>
        /// <param name="dbEntity"></param>
        /// <param name="es"></param>
        public void InsertBrotherTable(string className, DBEntity dbEntity, ElectronSymbol es)
        {
            try
            {
                var newObject_n = dbEntity.Clone() as ElectronBase;
                switch (className)
                {
                case "Connectivity_n":
                    _connectionTableData.Add(newObject_n as Connectivity_n);
                    newObject_n.EntityState = EntityState.Add_Nal_Nal;
                    break;

                case "Common_n":
                    //存储电房的G3E_ID
                    if (es.G3E_GEOMETRY is Polygon)
                    {
                        _subordinateDfTableData.Add((dbEntity as ElectronBase).G3E_ID, newObject_n as Common_n);
                    }
                    else
                    {
                        var comm = newObject_n as Common_n;
                        _subordinateSbTableData.Add(comm.G3E_ID, comm);
                    }
                    //清空设备名称
                    ClearCommon(newObject_n);
                    newObject_n.EntityState = EntityState.Insert;
                    break;

                case "Detailreference_n":
                    var detailref = newObject_n as Detailreference_n;
                    detailref.G3E_DETAILID    = CYZCommonFunc.getid();
                    detailref.EntityState     = EntityState.Insert;
                    detailref.DETAIL_USERNAME = es.G3E_FID.ToString();
                    newObject_n = detailref;
                    break;

                case "Gg_pd_gnwzmc_n":
                    ClearGnwzmcn(newObject_n);
                    newObject_n.EntityState = EntityState.Insert;
                    break;

                default:
                    newObject_n.EntityState = EntityState.Insert;
                    break;
                }
                newObject_n.G3E_FID = es.G3E_FID;
                newObject_n.G3E_ID  = es.G3E_ID;
                newObject_n.SetValue("LTT_ID", (decimal)MapConfig.Instance.LTTID);
                DBManager.Instance.Insert(newObject_n);
            }catch (Exception ex)
            {
                LogManager.Instance.Error(ex);
            }
        }
Пример #10
0
 /// <summary>
 /// 生成新的G3E系列ID
 /// </summary>
 /// <param name="OldG3e_fid"></param>
 /// <param name="oldParentG3e_id"> </param>
 /// <param name="g3e_IdMapping"></param>
 /// <returns></returns>
 public Dictionary <long, ExpandsData> CreateG3EFID(long OldG3e_fid, long oldParentG3e_id, Dictionary <long, ExpandsData> g3e_IdMapping)
 {
     if (!g3e_IdMapping.ContainsKey(OldG3e_fid))
     {
         var ed = new ExpandsData
         {
             newG3e_id       = CYZCommonFunc.getid(),
             newG3e_fid      = CYZCommonFunc.getid(),
             oldG3e_fid      = OldG3e_fid,
             oldParentG3e_Id = oldParentG3e_id
         };
         g3e_IdMapping.Add(OldG3e_fid, ed);
     }
     return(g3e_IdMapping);
 }
Пример #11
0
 /// <summary>
 /// 新增杂项标注
 /// </summary>
 /// <param name="parentfid">关联设备G3e_fid</param>
 /// <param name="text">标注内容</param>
 /// <param name="bzlx">标注类型</param>
 /// <param name="ssdw">所属单位</param>
 /// <param name="mpt">标注坐标</param>
 /// <param name="pt">返回标注坐标表对象</param>
 /// <returns>true成功,反之</returns>
 public static bool InsertZXBZ(long parentfid, string text, string bzlx, string ssdw, Multipoint mpt, ref ElectronSymbol pt)
 {
     try
     {
         var g3e_id  = CYZCommonFunc.getid();
         var g3e_fid = CYZCommonFunc.getid();
         InsertZXBZN(g3e_id, g3e_fid, parentfid, text, bzlx, ssdw);
         InsertZXBZLB(g3e_id, g3e_fid);
         pt = InsertZXBZLBSDOGEOM(g3e_id, g3e_fid, mpt);
         return(true);
     }catch (Exception ex)
     {
         LogManager.Instance.Error("新增杂项标注错误!" + ex);
     }
     return(false);
 }
Пример #12
0
        /// <summary>
        /// 判断新增设备 打开台账编辑页面
        /// </summary>
        public static string IsNewEquipmentAndURL(ObjectId objectId)
        {
            var  urlstr = string.Empty;
            long id = 0, fid = 0, fno = 0;

            try
            {
                var selectedEntity = PublicMethod.Instance.GetObject(objectId, OpenMode.ForRead);
                if (selectedEntity is DBText)
                {
                    PublicMethod.Instance.ShowMessage("你选择的是设备标注,请重新选择!");
                    return(null);
                }
                if (DBEntityFinder.Instance.GetG3EIds(selectedEntity.ObjectId, ref id, ref fid, ref fno))
                {
                    var ptVlaue = PublicMethod.Instance.GetDBSymbolFinder(objectId) as ElectronSymbol;
                    var com     = CYZCommonFunc.GetModelEntity(fid) as Common_n;
                    if (ptVlaue == null || com == null)
                    {
                        return(string.Empty);
                    }
                    //获取gis工单ID
                    var ltt_id = ptVlaue.GetValue("LTT_ID").ToString();

                    var sbmc = string.Empty;
                    if (!string.IsNullOrEmpty(com.SBMC))
                    {
                        sbmc = BitConverter.ToString(Encoding.UTF8.GetBytes(com.SBMC)).Replace("-", "<M>");
                    }
                    //获取FID 新增设备需加a
                    var g3efid = ptVlaue.EntityState == EntityState.Insert ? string.Format("a{0}", fid) : fid.ToString();
                    //编辑设备台帐信息默认为'Y'
                    urlstr = string.Format(
                        "http://localhost:9090/emmis/equipGisMappingTemp/getInstallEquipments.gis?" +
                        "g3e_fid={0}&" +
                        "jobId={1}&" +
                        "g3e_fno={2}&editAble=Y&" +
                        "funcplaceName={3}&jgdh=009",
                        g3efid, ltt_id, fno, sbmc);
                }
            }
            catch (System.Exception ex)
            {
                LogManager.Instance.Error(ex);
            }
            return(urlstr);
        }
Пример #13
0
        private void Add_Gg_pd_dyshb_n(long g3efid)
        {
            //插入Gg_pd_dyshb_n表
            var newEnt = new Gg_pd_dyshb_n
            {
                G3E_FID = g3efid,
                G3E_ID  = CYZCommonFunc.getid(),
                G3E_FNO = 160,
                G3E_CNO = 16001,
                G3E_CID = 1,
                YDH     = tbYDH.Text,
                YHXM    = tbYHXM.Text,
                BH      = tbBH.Text,
                GDH     = tbGDH.Text,
                HBLX    = tbHBLX.Text,
                DZJL    = tbDZJL.Text,
                AZDZ    = tbAZDZ.Text,
                CD_SSDW = tbCD_SSDW.Text,
                BXH     = tbBXH.Text,
                YDLB    = (String)(cbYDLB.SelectedItem),
                YHLX    = (String)(cbYHLX.SelectedItem),
                SMZQ    = (String)(cbSMZQ.SelectedItem),
                MBH     = tbMBH.Text,
                BZ      = tbBZ.Text,
                GZZT    = (String)(cbGZZT.SelectedItem),
                CD_SSXL = tbCD_SSXL.Text,
                HH      = tbHH.Text,
                XS      = (String)(cbXS.SelectedItem),
                QT      = tbQT.Text,
                SFYHYB  = tbSFYHYB.Text,
                //BZ1 = String.Format("{0}@1@{1}", tbYDH.Text, tbBH.Text), //协议号需要配网去填
                KHXYH       = tbXYH.Text,
                LTT_ID      = MapConfig.Instance.LTTID,
                EntityState = EntityState.Insert
            };

            //newEnt.LTT_DATE;
            //newEnt.LTT_STATUS;
            //newEnt.LTT_TID;
            //newEnt.DWFX_SFSDY;
            //newEnt.CD_SSBDZ;
            if (false == DBManager.Instance.Insert(newEnt))
            {
                throw new Exception("Add_Gg_pd_dyshb_n: 插入失败!");
            }
        }
Пример #14
0
        private void Add_Connectivity_n(long g3efid)
        {
            // 插入Connectivity_n
            var shbconn = new Connectivity_n
            {
                G3E_ID      = CYZCommonFunc.getid(),
                G3E_FNO     = 160,
                G3E_CNO     = 31,
                G3E_FID     = g3efid,
                G3E_CID     = 1,
                NODE1_ID    = 0,
                NODE2_ID    = 0,
                LTT_ID      = MapConfig.Instance.LTTID,
                EntityState = EntityState.Add_Nal_Nal
            };

            if (false == DBManager.Instance.Insert(shbconn))
            {
                throw new Exception("Add_Connectivity_n: 插入失败!");
            }
        }
Пример #15
0
        private static ElectronSymbol GetTjDBEntity(long oldG3e_fid, ElectronSymbol newObject_pt)
        {
            var parentGnwz = xmlDBManager.GetEntity <Gg_pd_gnwzmc_n>(oldG3e_fid);

            if (parentGnwz != null)
            {
                if (parentGnwz.GNWZ_FL2.Equals("台架"))
                {
                    var comTJ = xmlDBManager.GetEntity <Common_n>(o => o.G3E_FNO == 199 && o.G3E_FID.ToString().Equals(parentGnwz.GNWZ_SSTJ));
                    if (comTJ != null)
                    {
                        var newG3e_id  = CYZCommonFunc.getid();
                        var newG3e_fid = CYZCommonFunc.getid();

                        var com = xmlDBManager.GetEntity <Common_n>(comTJ.G3E_FID);
                        InsertElectronBase(com, newG3e_id, newG3e_fid);

                        var self = xmlDBManager.GetEntity <Gg_gz_tj_n>(comTJ.G3E_FID);
                        if (self != null)
                        {
                            //更新变压器的fid
                            self.GNWZ_FID = newObject_pt.G3E_FID.ToString();
                            InsertElectronBase(self, newG3e_id, newG3e_fid);
                        }
                        var gnwz = xmlDBManager.GetEntity <Gg_pd_gnwzmc_n>(comTJ.G3E_FID);
                        if (gnwz != null)
                        {
                            InsertElectronBase(gnwz, newG3e_id, newG3e_fid);
                            //更新父设备的所属台架
                            DBEntityCopy.Instance.UpdateGnwzSstj(newObject_pt.G3E_FID, newG3e_fid);
                        }
                    }
                }
            }
            return(newObject_pt);
        }
Пример #16
0
        /// <summary>
        /// 点击确定按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OkButton_Click(object sender, EventArgs e)
        {
            DialogResult = DialogResult.OK;
            try
            {
                if (string.IsNullOrEmpty(FidText.Text))
                {
                    MessageBox.Show("FID不能为空!!!");
                    return;
                }
                if (string.IsNullOrEmpty(NameText.Text.Trim()))
                {
                    MessageBox.Show("名称不能为空!!!");
                    return;
                }
                var sbmc = NameText.Text.Trim();
                var com  = DBManager.Instance.GetEntity <Common_n>(o => o.G3E_FID == long.Parse(FidText.Text));
                if (com == null)
                {
                    return;
                }
                if (m_ft == formType.regionAdd)//添加操作
                {
                    //查看是否重复添加
                    var kxNode = RegionalManagement.GetSeleteKX();
                    if (kxNode == null)
                    {
                        PublicMethod.Instance.ShowMessage("没有选择馈线,请再重试一遍\n");
                        //显示支线管理窗体
                        Autodesk.AutoCAD.ApplicationServices.Application.ShowModalDialog(RegionalManagement.GetCurActionForm());
                        return;
                    }
                    if (kxNode.Nodes.Cast <TreeNode>().Any(zx => zx.Name == FidText.Text))
                    {
                        PublicMethod.Instance.ShowMessage("支线已经存在\n");
                        return;
                    }
                    //获取属性
                    if (String.IsNullOrEmpty(FidText.Text))
                    {
                        throw new Exception();
                    }

                    //查看是否删除状态
                    Gnwz_tz_zx newEnt = null;
                    var        tmp    = DBEntityFinder.Instance.GetGnwzTzZx(long.Parse(FidText.Text));
                    if (tmp != null && tmp.EntityState == EntityState.Delete)//删除状态,恢复数据
                    {
                        tmp.EntityState = EntityState.Update;
                        DBManager.Instance.Update(tmp);
                    }
                    else//否则
                    {
                        //插入支线表
                        newEnt = new Gnwz_tz_zx
                        {
                            ID          = CYZCommonFunc.getid(),
                            G3E_FID     = com.G3E_FID,
                            IN_TIME     = DateTime.Now,
                            EntityState = EntityState.Insert
                        };
                    }
                    if (!com.Equals(sbmc))
                    {
                        //更新支线名称
                        com.SBMC        = NameText.Text;
                        com.EntityState = EntityState.Update;
                        DBManager.Instance.Update(com);
                    }

                    //把支线添加入TreeView中
                    kxNode.Nodes.Add(newEnt.G3E_FID.ToString(), sbmc);
                    DBManager.Instance.Insert(newEnt);
                    //如果是原始的电缆或导线变成了支线也要更新公共表的备注字段
                    var propertyName = GenerateHelper.QueryZXField(com.G3E_FNO);
                    if (!string.IsNullOrEmpty(propertyName))
                    {
                        if (com.EntityState == EntityState.None)
                        {
                            com.EntityState = EntityState.Update;
                        }
                        com.SetAttribute(propertyName, com.G3E_FID.ToString());
                        DBManager.Instance.Update(com);
                    }
                }
                else//编辑操作
                {
                    //更新支线名称
                    com.SBMC = NameText.Text;
                    if (com.EntityState != EntityState.Insert) //如果之前不是insert
                    {
                        com.EntityState = EntityState.Update;  //修改成update
                    }
                    DBManager.Instance.Update(com);

                    //更新TreeView中支线名称
                    var kxNode = RegionalManagement.GetSeleteKX();
                    if (kxNode != null)
                    {
                        kxNode.Nodes.Find(FidText.Text, true)[0].Text = sbmc;
                    }
                    else
                    {
                        PublicMethod.Instance.ShowMessage("没有正确选择支线");
                    }
                }
            }
            catch (Exception exception) {
                PublicMethod.Instance.ShowMessage("操作过程中出现错误" + exception);
            }
            finally
            {
                this.Close();
            }
        }
Пример #17
0
        /// <summary>
        /// 添加属性表数据
        /// </summary>
        /// <param name="cso"></param>
        /// <param name="es"></param>
        /// <returns></returns>
        private ElectronSymbol InsertElectronBase(CopySymbolObject cso, ElectronSymbol es)
        {
            var flag           = false;
            var otherIdMapping = new Dictionary <long, ExpandsData>();

            foreach (var dbEntity in cso.hsDBEntity)
            {
                var newObject = dbEntity.dbEntity as ElectronBase;
                if (dbEntity.className.Contains("Contain"))
                {
                    //如果电杆存在,则根据电杆的FID去导线的包含关系表去查询,
                    //根据导线的包含关系表中的G3E_OWNERFID是否等于电杆的FID,
                    //反之只有导线复制的话,则取导线的任意一条对应的包含关系清空G3E_OWNERFID值即可。
                    if (es.G3E_FNO != 141)
                    {
                        SetContainTable(newObject, es.G3E_FID, false);
                    }
                    else
                    {
                        var bl = HasDg(cso.hsDBEntity);
                        if (bl)
                        {
                            //判断当前数据是否有被电杆包含
                            if (HasDg(dbEntity.dbEntity))
                            {
                                SetContainTable(newObject, es.G3E_FID, false);
                            }
                        }
                        else
                        {
                            //导线有被电杆包含,但是当前没有拷贝电杆,所以只取其中任意一条包含数据,清空G3E_OWNERFID值即可。
                            if (!flag)
                            {
                                SetContainTable(newObject, es.G3E_FID, true);
                                flag = true;
                            }
                        }
                    }
                }
                else if (dbEntity.className.Equals("Gg_pd_sdkx_ac"))
                {
                    var g3d_id = CYZCommonFunc.getid();
                    var sdkxac = newObject as Gg_pd_sdkx_ac;
                    sdkxac.G3E_ID      = g3d_id;
                    sdkxac.G3E_FID     = es.G3E_FID;
                    sdkxac.EntityState = EntityState.Insert;
                    sdkxac.SetValue("LTT_ID", (decimal)MapConfig.Instance.LTTID);
                    DBManager.Instance.Insert(sdkxac);
                }
                else
                {
                    //台架和开关柜
                    if (newObject.G3E_FNO == 198 || newObject.G3E_FNO == 199)
                    {
                        otherIdMapping = CreateG3EFID(newObject.G3E_FID, es.G3E_ID, otherIdMapping);
                        AddKggDBEntity(es.G3E_FID, newObject, otherIdMapping);
                    }
                    else
                    {
                        InsertBrotherTable(dbEntity.className, newObject, es);
                    }
                }
            }
            return(es);
        }
Пример #18
0
        private void Add_Gg_jx_shbd_pt_sdogeom(long sdogid, long g3efid)
        {
            var shbsdo = new Gg_jx_shbd_pt_sdogeom
            {
                G3E_FID     = g3efid,
                G3E_FNO     = 160,
                G3E_ID      = CYZCommonFunc.getid(),
                SDO_GID     = sdogid,
                G3E_CNO     = 16004,
                G3E_CID     = 1,
                LTT_ID      = MapConfig.Instance.LTTID,
                EntityState = EntityState.Insert
            };
            double x, y;

            // 获取坐标
            if (shbPositon != Point3d.Origin)
            {
                x = shbPositon.X;
                y = shbPositon.Y;
            }
            else
            {
                x = (MapConfig.Instance.ProjectionMaxX + MapConfig.Instance.ProjectionMinX) / 2;
                y = (MapConfig.Instance.ProjectionMaxY + MapConfig.Instance.ProjectionMinY) / 2;
            }
            var mpValue = new Multipoint();

            mpValue.Points.Add(new Point(new[] { x, y, 0 }));
            mpValue.Points.Add(new Point(new[] { Math.Cos(0.0), Math.Sin(0.0), 0 }));
            shbsdo.G3E_GEOMETRY = mpValue;

            if (false == DBManager.Instance.Insert(shbsdo))
            {
                throw new Exception("Add_Gg_jx_shbd_pt_sdogeom: 插入失败!");
            }
            #region
            //shbsdo.SDO_ESEQ
            //SDO_ETYPE
            //SDO_SEQ
            //GDO_ATTRIBUTES
            //GDO_NORMAL1
            //GDO_NORMAL2
            //GDO_NORMAL3
            //GDO_RADIUS
            //SDO_ORIENTATION
            //SDO_X1
            //SDO_Y1
            //SDO_X2
            //SDO_Y2
            //SDO_X3
            //SDO_Y3
            //SDO_X4
            //SDO_Y4
            //G3E_ID
            //G3E_FNO
            //G3E_FID
            //LTT_STATUS
            //LTT_DATE
            //LTT_TID
            #endregion
        }
Пример #19
0
        /// <summary>
        /// 更新连接关系表
        /// 把node1、node2相同的值更新
        /// 把不相同的赋0
        /// </summary>
        public void UpdateConnectionData()
        {
            var g3enode_cadnode = new Dictionary <string, string>();
            var compare         = _connectionTableData.Select(item => item.Clone() as Connectivity_n).ToList();

            try
            {
                if (compare.Count > 0)
                {
                    var nodes = GetNodes(compare);
                    foreach (var item in compare)
                    {
                        bool bNode1 = false, bNode2 = false;
                        if (g3enode_cadnode.ContainsKey(item.NODE1_ID.ToString()))
                        {
                            item.NODE1_ID = long.Parse(g3enode_cadnode[item.NODE1_ID.ToString()]);
                            bNode1        = true;
                        }
                        else
                        {
                            Connectivity_n item1 = item;
                            if (nodes.Count(o => o == item1.NODE1_ID.ToString()) > 1)
                            {
                                string nodeId = CYZCommonFunc.getid().ToString();
                                g3enode_cadnode.Add(item.NODE1_ID.ToString(), nodeId);
                                item.NODE1_ID = long.Parse(nodeId);
                                bNode1        = true;
                            }
                            else
                            {
                                item.NODE1_ID = 0;
                            }
                        }
                        if (g3enode_cadnode.ContainsKey(item.NODE2_ID.ToString()))
                        {
                            item.NODE2_ID = long.Parse(g3enode_cadnode[item.NODE2_ID.ToString()]);
                            bNode2        = true;
                        }
                        else
                        {
                            Connectivity_n item1 = item;
                            if (nodes.Count(o => o == item1.NODE2_ID.ToString()) > 1)
                            {
                                string nodeId = CYZCommonFunc.getid().ToString();
                                g3enode_cadnode.Add(item.NODE2_ID.ToString(), nodeId);
                                item.NODE2_ID = long.Parse(nodeId);
                                bNode2        = true;
                            }
                            else
                            {
                                item.NODE2_ID = 0;
                            }
                        }
                        if (bNode1 && bNode2)
                        {
                            item.EntityState = EntityState.Add_Add_Add;
                        }
                        else if (!bNode1 && bNode2)
                        {
                            item.EntityState = EntityState.Add_Nal_Add;
                        }
                        else if (!bNode1 && !bNode2)
                        {
                            item.EntityState = EntityState.Add_Nal_Nal;
                        }
                        else if (bNode1 && !bNode2)
                        {
                            item.EntityState = EntityState.Add_Add_Nal;
                        }
                    }
                    compare.ForEach(o => DBManager.Instance.Update(o));
                    //处理从属关系
                    UpdateSubordinateTable();
                    //处理包含关系
                    UpdateContainTable();
                }
            }
            catch (Exception ex)
            {
                LogManager.Instance.Error(ex);
            }
            finally
            {
                _connectionTableData.Clear();
                _subordinateSbTableData.Clear();
                _containDxTableData.Clear();
                _containDgTableData.Clear();
                _subordinateDfTableData.Clear();
            }
        }
Пример #20
0
        /// <summary>
        /// 建立连接关系
        /// </summary>
        /// <param name="objIdList">需要建立连接的设备列表</param>
        /// <returns>成功返回true,失败返回false</returns>
        bool buildConnByObjIdList(ObjectIdList objIdList)
        {
            var  hasEr = false;
            var  db = HostApplicationServices.WorkingDatabase;
            var  connList = new List <Connectivity_n>();
            long g3eid = 0, g3efid = 0, g3efno = 0;
            var  hasConn = false;

            // 判断已选择的设备是否已经存在连接关系
            foreach (var id in objIdList)
            {
                DBEntityFinder.Instance.GetG3EIds(id, ref g3eid, ref g3efid, ref g3efno);
                var conn = DBManager.Instance.GetEntity <Connectivity_n>(g3efid);
                if (conn.NODE1_ID != 0 || conn.NODE2_ID != 0)
                {
                    hasConn = true;
                }
                connList.Add(conn);
            }
            var dlgRes = DialogResult.Yes;

            if (hasConn)
            {
                dlgRes = MessageBox.Show(@"选择中的设备已有连接关系。
是否打断重新建立?", @"AutoCad", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                if (dlgRes != DialogResult.Yes)
                {
                    throw new Exception("cancel");
                }
                // 打断关系
                TopologyMethods.breakall(objIdList);
            }
            using (var tr = db.TransactionManager.StartTransaction())
            {
                // 建立关系
                for (var i = 0; i < connList.Count - 1; i++)
                {
                    var newNode = CYZCommonFunc.getid();
                    if (accordConnCrom(connList[i].G3E_FNO, connList[i + 1].G3E_FNO))
                    {
                        // 判断设备是否只有一个连接点     143-站房母线  159-低压集中抄表箱 79-低压母线 151-10kV电缆终端头 74-低压终端 72-接地挂环 85-PT柜 清空节点2
                        if (PublicMethod.Instance.N2is0.Concat(PublicMethod.Instance.N1isN2).Contains(connList[i].G3E_FNO))
                        {
                            if (connList[i].NODE1_ID == 0) // 若果母线连接1为0
                            {
                                if (PublicMethod.Instance.N1isN2.Contains(connList[i].G3E_FNO))
                                {
                                    connList[i].NODE1_ID = connList[i].NODE2_ID = connList[i + 1].NODE1_ID = newNode;
                                    TopologyMethods.ChangEntStatus(connList[i], 2, "Add");
                                }
                                else
                                {
                                    connList[i].NODE1_ID = connList[i + 1].NODE1_ID = newNode;
                                }
                                TopologyMethods.ChangEntStatus(connList[i], 1, "Add");
                            }
                            else // 否则直接将母线连接1赋值给下一个设备
                            {
                                if (PublicMethod.Instance.N1isN2.Contains(connList[i].G3E_FNO))
                                {
                                    connList[i + 1].NODE1_ID = connList[i].NODE2_ID = connList[i].NODE1_ID;
                                    TopologyMethods.ChangEntStatus(connList[i], 2, "Add");
                                }
                                else
                                {
                                    connList[i + 1].NODE1_ID = connList[i].NODE1_ID;
                                }
                            }
                        }
                        else/* if (sinNodDevArr.Contains(connList[i + 1].G3E_FNO))*/
                        {
                            connList[i].NODE2_ID = connList[i + 1].NODE1_ID = newNode;
                            TopologyMethods.ChangEntStatus(connList[i], 2, "Add");
                            if (PublicMethod.Instance.N1isN2.Contains(connList[i + 1].G3E_FNO))
                            {
                                connList[i + 1].NODE2_ID = newNode;
                                TopologyMethods.ChangEntStatus(connList[i + 1], 2, "Add");
                            }
                        }
                        TopologyMethods.ChangEntStatus(connList[i + 1], 1, "Add");
                        DBManager.Instance.Update(connList[i]);// 改变状态
                    }
                    else
                    {
                        hasEr = true;
                        ConnlistView.Items[i].ForeColor     = Color.Red;
                        ConnlistView.Items[i + 1].ForeColor = Color.Red;
                    }
                }
                // 更新列表最后一个设备连接状态
                DBManager.Instance.Update(connList[connList.Count - 1]);
                tr.Commit();
            }
            return(hasEr);
        }
Пример #21
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            try
            {
                //判断输入的属性规范
                if (hasError())
                {
                    return;
                }

                if (Ft == formType.regionAdd)//添加操作
                {
                    //检查户表是否存在
                    var tmp = GetDYSHB_N();
                    if (tmp != null)//存在
                    {
                        #region
                        //如状态是Delete,则改回None
                        if (tmp.EntityState == EntityState.Delete)
                        {
                            tmp.EntityState = EntityState.None;
                            DBManager.Instance.Update(tmp);
                        }
                        //检查从属关系是否存在
                        var v = DBManager.Instance.GetEntity <Gg_jx_shbd_pt>(o => o.G3E_FID == FID);
                        if (v != null)//存在
                        {
                            //如状态是Delete,则改回None
                            if (v.EntityState == EntityState.Delete)
                            {
                                v.EntityState = EntityState.None;
                                DBManager.Instance.Update(v);
                            }
                        }
                        else//不存在则插入
                        {
                            var           t  = DBManager.Instance.GetEntity <Detailreference_n>(o => o.G3E_FID == FID);
                            Gg_jx_shbd_pt t2 = new Gg_jx_shbd_pt();
                            t2.G3E_DETAILID  = t.G3E_DETAILID;
                            t2.G3E_FNO       = 160;
                            t2.G3E_CNO       = 16004;
                            t2.G3E_FID       = tmp.G3E_FID;
                            t2.G3E_ALIGNMENT = 0;
                            t2.G3E_ID        = CYZCommonFunc.getid();
                            t2.G3E_CID       = 1;
                            t2.LTT_ID        = MapConfig.Instance.LTTID;
                            t2.EntityState   = EntityState.Insert;
                            DBManager.Instance.Insert(t2);
                        }
                        #endregion
                    }
                    else//不存在
                    {
                        var g3efid = CYZCommonFunc.getid();
                        //插入Gg_pd_dyshb_n表
                        Add_Gg_pd_dyshb_n(g3efid);

                        //增加Gg_jx_shbd_pt表
                        var sdogid = Add_Gg_jx_shbd_pt(g3efid);

                        //增加Gg_jx_shbd_pt_sdogeom
                        Add_Gg_jx_shbd_pt_sdogeom(sdogid, g3efid);

                        //增加Gg_jx_shbd_lb
                        Add_Gg_jx_shbd_lb(g3efid);

                        //增加Connectivity_n
                        //Add_Connectivity_n(g3efid);
                        g_newFid = g3efid;
                    }
                }
                else//编辑操作
                {
                    //更新表数据
                    UpdateDYSHB();
                }
                AZDZ         = tbAZDZ.Text;
                DialogResult = DialogResult.OK;
                Close();
            }
            catch (Exception ee)
            {
                PublicMethod.Instance.ShowMessage(String.Format("操作过程中出现错误:{0}", ee.Message));
            }
        }
Пример #22
0
 /// <summary>
 /// 得到当前集抄箱的户表集合
 /// </summary>
 /// <returns>户表集合</returns>
 private IEnumerable <Gg_pd_dyshb_n> GetSHB_NS()
 {
     try
     {
         string alertMessage = "";
         var    shbs         = new List <Gg_pd_dyshb_n>();
         var    detail       = DBManager.Instance.GetEntities <Detailreference_n>(o => o.G3E_FID == detail_fid && o.EntityState != EntityState.Delete).FirstOrDefault();
         if (detail == null)
         {
             PublicMethod.Instance.Add_Detailreference_n(detail_id, detail_fid, detail_fno);
             return(null);
         }
         // 更正详图信息
         if (detail.DETAIL_USERNAME == null)
         {
             detail.DETAIL_USERNAME = detail.G3E_FID.ToString();
         }
         if (detail.G3E_DETAILID == null)
         {
             detail.G3E_DETAILID = CYZCommonFunc.getid();
         }
         if (detail.EntityState != EntityState.Insert)
         {
             detail.EntityState = EntityState.Update;
         }
         var jxshbs = DBManager.Instance.GetEntities <Gg_jx_shbd_pt>(o => o.G3E_DETAILID == detail.G3E_DETAILID && o.EntityState != EntityState.Delete);
         if (jxshbs == null)
         {
             return(null);
         }
         foreach (var shb in jxshbs)
         {
             var s = GetSHB_N(shb.G3E_FID);
             if (s == null)
             {
                 alertMessage += " " + shb.G3E_FID;
                 continue;
             }
             shbs.Add(s);
         }
         if (!string.IsNullOrEmpty(alertMessage))
         {
             PublicMethod.Instance.AlertDialog("在Gg_pd_dyshb_n表没有FID为" + alertMessage + " 的数据.");
         }
         return(shbs);
     }
     catch (NotExistException ex)
     {
         if (ex.Message.Contains("不存在"))
         {
             var strlx    = ex.Message.Replace("不存在", "");
             var type     = TypeCache.Instance.GetTypeFromCache(typeof(DBEntity), strlx);
             var connectn = ReflectionUtils.CreateObject(new {}, type) as DBEntity;
             DBManager.Instance.Insert(connectn);
         }
         else
         {
             PublicMethod.Instance.AlertDialog(ex.Message);
         }
         return(null);
     }
     catch (Exception ex)
     {
         PublicMethod.Instance.AlertDialog(ex.Message);
         return(null);
     }
 }
Пример #23
0
        private void Ok_Btn_Click(object sender, EventArgs e)
        {
            try
            {
                // 是否已选择了母线
                if (MxName_textBox.Tag == null || MxFid_textBox.Tag == null)
                {
                    PublicMethod.Instance.AlertDialog("请先选择母线"); return;
                }
                // 是否已选择了上下游设备
                if (SelYxCount_Lab.Text == "0")
                {
                    PublicMethod.Instance.AlertDialog("请先选择上下游设备"); return;
                }
                // 是否已确定上下游方向
                if (InRadBtn.Checked == false && OutRadBtn.Checked == false)
                {
                    PublicMethod.Instance.AlertDialog("请先选择上下游方向"); return;
                }

                var IdListFromView = new ObjectIdList();
                IdListFromView.AddRange(from ListViewItem item in YxlistView.Items select(ObjectId) item.Tag);

                long g3eid = 0, g3efid = 0, g3efno = 0;
                var  mxfid   = (long)MxFid_textBox.Tag;
                var  nodeid  = CYZCommonFunc.getid();
                var  strNodC = "";
                using (doc.LockDocument())
                {
                    using (db.TransactionManager.StartTransaction())
                    {
                        var conn   = DBManager.Instance.GetEntity <Connectivity_n>(mxfid);
                        var dlgRes = DialogResult.Yes;
                        if ((conn.NODE1_ID != 0 && InRadBtn.Checked) || (conn.NODE2_ID != 0 && OutRadBtn.Checked) ||
                            (conn.NODE1_ID != 0 && conn.G3E_FNO == 143))
                        {
                            dlgRes = MessageBox.Show(
                                "已有连接关系" +
                                "\n 是     连接已有 " +
                                "\n 否     打断重建 ",
                                "AutoCad",
                                MessageBoxButtons.YesNoCancel,
                                MessageBoxIcon.Warning);
                            if (!(dlgRes == DialogResult.Yes || dlgRes == DialogResult.No))
                            {
                                return;
                            }
                            if (dlgRes == DialogResult.Yes)
                            {
                                if (InRadBtn.Checked)
                                {
                                    if (conn.NODE1_ID != null)
                                    {
                                        nodeid = (int)conn.NODE1_ID;
                                    }
                                }
                                else
                                {
                                    if (conn.NODE2_ID != null)
                                    {
                                        nodeid = (int)conn.NODE2_ID;
                                    }
                                }
                                var tempstr = conn.EntityState.ToString();
                                if (tempstr.Length > 7)
                                {
                                    tempstr = tempstr.Substring(4, 3);
                                }
                                switch (tempstr)
                                {
                                case "None":
                                    strNodC = "Old";
                                    break;

                                case "Update":
                                    strNodC = "Old";
                                    break;

                                default:
                                    strNodC = tempstr;
                                    break;
                                }
                            }
                        }
                        if (dlgRes == DialogResult.No || conn.NODE1_ID == 0)
                        {
                            strNodC = "Add";
                            if (conn.G3E_FNO == 143)
                            {
                                conn.NODE1_ID = conn.NODE2_ID = nodeid;
                                /*改变母线状态*/
                                TopologyMethods.ChangEntStatus(conn, 1, "Add");
                                TopologyMethods.ChangEntStatus(conn, 2, "Add");
                            }
                            else
                            {
                                if (OutRadBtn.Checked)
                                {
                                    conn.NODE2_ID = nodeid;
                                    TopologyMethods.ChangEntStatus(conn, 2, "Add");
                                }
                                else
                                {
                                    conn.NODE1_ID = nodeid;
                                    TopologyMethods.ChangEntStatus(conn, 1, "Add");
                                }
                            }
                        }
                        //int[] sinNodDevArr = new int[] { 11, 72, 79, 85, 120, 143, 167, 173 };
                        foreach (var id in IdListFromView)
                        {
                            DBEntityFinder.Instance.GetG3EIds(id, ref g3eid, ref g3efid, ref g3efno);
                            conn = DBManager.Instance.GetEntity <Connectivity_n>(g3efid);
                            if (OutRadBtn.Checked || PublicMethod.Instance.N2is0.Concat(PublicMethod.Instance.N1isN2).Contains(conn.G3E_FNO))
                            {
                                conn.NODE1_ID = nodeid;
                                TopologyMethods.ChangEntStatus(conn, 1, strNodC);
                            }
                            else
                            {
                                conn.NODE2_ID = nodeid;
                                TopologyMethods.ChangEntStatus(conn, 2, strNodC);
                            }
                            sinNodDevJudge(conn);
                        }
                    }
                }
                TopologyMethods.bChangeTopo = true;
                PublicMethod.Instance.AlertDialog("建立完成");
            }
            catch (Exception ex) { ed.WriteMessageWithReturn(ex.Message + "\n"); }
        }
Пример #24
0
        private IEnumerable <Gg_pd_jlb_n> GetJLB_NS()
        {
            try
            {
                string alertMessage = "";
                var    detail       =
                    DBManager.Instance.GetEntities <Detailreference_n>(
                        o => o.G3E_FID == detail_fid && o.EntityState != EntityState.Delete).FirstOrDefault(); //为空
                if (detail == null)
                {
                    // 添加详图数据
                    PublicMethod.Instance.Add_Detailreference_n(detail_id, detail_fid, detail_fno);
                    return(null);
                }
                if (detail.DETAIL_USERNAME == null)
                {
                    detail.DETAIL_USERNAME = detail.G3E_FID.ToString();
                }
                if (detail.G3E_DETAILID == null)
                {
                    detail.G3E_DETAILID = CYZCommonFunc.getid();
                }
                if (detail.EntityState != EntityState.Insert)
                {
                    detail.EntityState = EntityState.Update;
                }
                DBManager.Instance.Update(detail);

                var jlbs   = new List <Gg_pd_jlb_n>();
                var jxjlbs =
                    DBManager.Instance.GetEntities <Gg_jx_jlb_pt>(
                        o => o.G3E_DETAILID == detail.G3E_DETAILID && o.EntityState != EntityState.Delete);
                if (jxjlbs == null)
                {
                    return(null);
                }
                foreach (var jlb in jxjlbs)
                {
                    var s = GetJLB_N(jlb.G3E_FID);
                    if (s == null)
                    {
                        alertMessage += " " + jlb.G3E_FID;
                        continue;
                    }
                    jlbs.Add(s);
                }
                if (!string.IsNullOrEmpty(alertMessage))
                {
                    PublicMethod.Instance.AlertDialog("在Gg_pd_jlb_n表没有FID为" + alertMessage + " 的数据.");
                }
                return(jlbs);
            }
            catch (NotExistException ex)
            {
                PublicMethod.Instance.NotExistTable(ex);
                return(null);
            }
            catch (Exception)
            {
                return(null);
            }
        }
Пример #25
0
 /// <summary>
 /// 更新变压器的详图设备馈线属性
 /// </summary>
 /// <param name="detail_fid">变压器G3E_FID</param>
 /// <returns></returns>
 public void UpdateJLB(long detail_fid)
 {
     try
     {
         var detail = DBManager.Instance.GetEntities <Detailreference_n>(o => o.G3E_FID == detail_fid && o.EntityState != EntityState.Delete).FirstOrDefault();
         if (detail == null)
         {
             return;
         }
         // 更正详图信息
         if (detail.DETAIL_USERNAME == null)
         {
             detail.DETAIL_USERNAME = detail.G3E_FID.ToString();
         }
         if (detail.G3E_DETAILID == null)
         {
             detail.G3E_DETAILID = CYZCommonFunc.getid();
         }
         if (detail.EntityState != EntityState.Insert)
         {
             detail.EntityState = EntityState.Update;
         }
         DBManager.Instance.Update(detail);
         // 得到 详图设备
         var jxjlbs = DBManager.Instance.GetEntities <Gg_jx_jlb_pt>(o => o.G3E_DETAILID == detail.G3E_DETAILID && o.EntityState != EntityState.Delete);
         if (jxjlbs == null)
         {
             return;
         }
         // 得到 计量表 或 变压器 公共属性
         var detail_com = DBManager.Instance.GetEntity <Common_n>(detail_fid);
         if (detail_com == null)
         {
             return;
         }
         // 更新详图设备馈线属性
         foreach (var jlb in jxjlbs)
         {
             var s = GetDEV_COM(jlb.G3E_FID);
             if (s == null)
             {
                 continue;
             }
             s.CD_SSDW  = detail_com.CD_SSDW;
             s.CD_SSXL  = detail_com.CD_SSXL;
             s.CD_SSBDZ = detail_com.CD_SSBDZ;
             //s.GNWZ_SSGDS = detail_com.GNWZ_SSGDS;
             if (s.EntityState != EntityState.Insert)
             {
                 s.EntityState = EntityState.Update;
             }
             DBManager.Instance.Update(s);
         }
     }
     catch (NotExistException ex)
     {
         PublicMethod.Instance.NotExistTable(ex);
     }
     catch (Exception)
     {
     }
 }
Пример #26
0
        public void autoc()
        {
            Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
            Database db  = HostApplicationServices.WorkingDatabase;
            Editor   ed  = doc.Editor;

            try
            {
                PublicMethod.Instance.AlertDialog("请选择第一个设备:");
                PromptEntityResult per1 = ed.GetEntity("");
                if (per1.Status != PromptStatus.OK)
                {
                    return;
                }
                // 工单判断
                if (DBEntityFinder.Instance.VerifyLTTID(per1.ObjectId) == false)
                {
                    PublicMethod.Instance.ShowMessage("您选择的设备没有被锁定,请重新选择\n");
                    return;
                }
                long fid = 0, id = 0, fno = 0;
                DBEntityFinder.Instance.GetG3EIds(per1.ObjectId, ref id, ref fid, ref fno);
                var conn = DBManager.Instance.GetEntity <Connectivity_n>(fid);
                if (conn == null)
                {
                    ed.WriteMessageWithReturn("该设备没有连接关系,Connectivity_n表的数据。\n");
                    return;
                }
                if (conn.NODE2_ID != 0)
                {
                    PublicMethod.Instance.AlertDialog("该设备已有连接关系。");
                    return;
                }
                long[] sdarr = { 11, 72, 79, 85, 120, 143, 167, 173 };
                if (sdarr.Contains(conn.G3E_FNO))
                {
                    PublicMethod.Instance.AlertDialog("第一个设备不能是仅有一个连接点的设备,如: 接地刀闸,母线");
                    return;
                }
                changCol(per1.ObjectId);

                PublicMethod.Instance.AlertDialog("请选择第二个设备:");
                PromptEntityResult per2 = ed.GetEntity("");
                if (per2.Status != PromptStatus.OK || per1.ObjectId == per2.ObjectId)
                {
                    return;
                }
                // 工单判断
                if (DBEntityFinder.Instance.VerifyLTTID(per2.ObjectId) == false)
                {
                    PublicMethod.Instance.ShowMessage("您选择的设备没有被锁定,请重新选择\n");
                    return;
                }
                // 把两个设备放进要过滤的列表
                if (!serobjs.Contains(per1.ObjectId))
                {
                    serobjs.Add(per1.ObjectId);
                }
                if (!serobjs.Contains(per2.ObjectId))
                {
                    serobjs.Add(per2.ObjectId);
                }
                // 得到当前视图
                ViewTableRecord view = ed.GetCurrentView();
                // 获取一个新的id
                int nodeid = CYZCommonFunc.getid();
                DCadApi.isModifySymbol = true;
                // 判断前两个设备是否能相连
                if (obj21obj(nodeid, per1.ObjectId, per2.ObjectId))
                {
                    using (doc.LockDocument())
                    {
                        db.UpdateExt(true);
                        ed.ZoomExtents();        // 视图最大化
                        autoconn(per2.ObjectId);
                        ed.SetCurrentView(view); // 还原视图
                    }
                    TopologyMethods.bChangeTopo = true;
                    PublicMethod.Instance.AlertDialog("连接结束!");
                }
            }
            catch (Exception ex) { ed.WriteMessageWithReturn(ex); }
            finally
            {
                DCadApi.isModifySymbol = false;
                clearCol();
                serobjs.Clear();
            }
        }
Пример #27
0
 /// <summary>
 /// 更新集抄箱的详图设备馈线属性
 /// </summary>
 /// <param name="detail_fid">集抄箱G3E_FID</param>
 /// <returns></returns>
 public void UpdateSHB(long detail_fid)
 {
     try
     {
         var detail = DBManager.Instance.GetEntities <Detailreference_n>(o => o.G3E_FID == detail_fid && o.EntityState != EntityState.Delete).FirstOrDefault();
         if (detail == null)
         {
             return;
         }
         // 更正详图信息
         if (detail.DETAIL_USERNAME == null)
         {
             detail.DETAIL_USERNAME = detail.G3E_FID.ToString();
         }
         if (detail.G3E_DETAILID == null)
         {
             detail.G3E_DETAILID = CYZCommonFunc.getid();
         }
         if (detail.EntityState != EntityState.Insert)
         {
             detail.EntityState = EntityState.Update;
         }
         // 得到 详图设备
         var jxshbs = DBManager.Instance.GetEntities <Gg_jx_shbd_pt>(o => o.G3E_DETAILID == detail.G3E_DETAILID && o.EntityState != EntityState.Delete);
         if (jxshbs == null)
         {
             return;
         }
         // 得到集抄箱的自身属性
         var shb_n = DBManager.Instance.GetEntity <Gg_pd_cbx_n>(detail_fid);
         foreach (var shb in jxshbs)
         {
             var s = DBManager.Instance.GetEntity <Gg_pd_dyshb_n>(shb.G3E_FID);
             if (s == null)
             {
                 continue;
             }
             s.CD_SSDW = shb_n.CD_SSDW;
             s.CD_SSXL = shb_n.CD_SSXL;
             if (s.EntityState != EntityState.Insert)
             {
                 s.EntityState = EntityState.Update;
             }
             DBManager.Instance.Update(s);
         }
     }
     catch (NotExistException ex)
     {
         if (ex.Message.Contains("不存在"))
         {
             var strlx    = ex.Message.Replace("不存在", "");
             var type     = TypeCache.Instance.GetTypeFromCache(typeof(DBEntity), strlx);
             var connectn = ReflectionUtils.CreateObject(new { }, type) as DBEntity;
             DBManager.Instance.Insert(connectn);
         }
         else
         {
             PublicMethod.Instance.AlertDialog(ex.Message);
         }
     }
     catch (Exception ex)
     {
         PublicMethod.Instance.AlertDialog(ex.Message);
     }
 }
Пример #28
0
        /// <summary>
        /// 添加线
        /// </summary>
        /// <param name="fid">杆的Fid</param>
        /// <param name="selFid">线的Fid</param>
        public static void addLine(long fid, long selFid)
        {
            // 判断杆在contain表中是否有数据
            //var role = DBManager.Instance.GetEntities<Contain_n>(o => o.G3E_FID == fid && o.EntityState != EntityState.Delete).FirstOrDefault();
            //if (null == role)
            //{
            //    LogManager.Instance.Error(String.Format("Contain_n 没有此杆的数据,不能做包含关系.杆G3e_Fid = {0}\n", fid));
            //    PublicMethod.Instance.AlertDialog(String.Format("Contain_n 没有此杆的数据,不能做包含关系.杆G3e_Fid = {0}\n", fid));
            //    return;
            //}
            // 工单判断
            if (false == DBEntityFinder.Instance.VerifyLTTID(selFid))
            {
                PublicMethod.Instance.AlertDialog(selFid + " 10kV 导线没有被工单锁定,不能包含.");
                return;
            }
            // 判断是否已经被此线重复包含
            var v = DBManager.Instance.GetEntity <Contain_n>(o => o.G3E_FID == selFid &&
                                                             o.EntityState != EntityState.Delete &&
                                                             o.EntityState != EntityState.InsertDelete &&
                                                             o.G3E_OWNERFID == fid);

            if (null != v)
            {
                PublicMethod.Instance.AlertDialog(selFid + " 10kV 导线已经被此杆包含.\n");
                return;
            }

            // 获取实体对象
            var _v = DBManager.Instance.GetEntities <Contain_n>(o => o.G3E_FID == selFid).Where(o => o.EntityState != EntityState.Delete);
            var nv = new Contain_n
            {
                G3E_FNO      = 141,
                G3E_FID      = selFid,
                G3E_CNO      = 38,
                G3E_ID       = CYZCommonFunc.getid(),
                G3E_OWNERFID = fid,
                G3E_OWNERFNO = 201,
                LTT_ID       = MapConfig.Instance.LTTID,
                LTT_DATE     = null,
                LTT_STATUS   = null
            };

            if (_v.Any())
            {
                v = _v.OrderBy(o => o.G3E_CID).Last();

                if (0 == v.G3E_OWNERFID)
                {
                    v.G3E_OWNERFID = fid;
                    v.G3E_OWNERFNO = 201;
                    if (v.EntityState == EntityState.None)
                    {
                        v.EntityState = EntityState.Update;
                    }
                    DBManager.Instance.Update(v);
                }
                else
                {
                    nv.G3E_CID = v.G3E_CID + 1;
                    // 更新实体ownerid
                    nv.EntityState = EntityState.Insert;
                    DBManager.Instance.Insert(nv);
                }
            }
            else
            {
                nv.G3E_CID = 1;
                // 更新实体ownerid
                nv.EntityState = EntityState.Insert;
                DBManager.Instance.Insert(nv);
                if (DBManager.Instance.GetEntities <Contain_n>(o => o.G3E_FID == fid).All(o => o.EntityState == EntityState.Delete))
                {
                    var onv = new Contain_n
                    {
                        G3E_FNO      = 201,
                        G3E_FID      = fid,
                        G3E_CNO      = 38,
                        G3E_CID      = 1,
                        G3E_ID       = CYZCommonFunc.getid(),
                        G3E_OWNERFID = 0,
                        G3E_OWNERFNO = 0,
                        LTT_ID       = MapConfig.Instance.LTTID,
                        LTT_DATE     = null,
                        LTT_STATUS   = null,
                        EntityState  = EntityState.Insert
                    };
                    DBManager.Instance.Insert(onv);
                }
            }
        }
Пример #29
0
        /// <summary>
        /// 对objid 的对象作空间分析
        /// </summary>
        /// <param name="objid">对象ObjectId</param>
        public void autoconn(ObjectId objid)
        {
            // 工单判断
            if (DBEntityFinder.Instance.VerifyLTTID(objid) == false)
            {
                return;
            }
            var doc       = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
            var ed        = doc.Editor;
            var autoconns = new ObjectIdList();
            var nodeid    = CYZCommonFunc.getid();
            var objs      = new List <ObjectId>();

            long[] mxarr = { 11, 120, 143, 167, 79 };
            long   idd = 0, fidd = 0, fnoo = 0;

            //ObjectIdList dxIdList = new ObjectIdList();
            try
            {
                DCadApi.isModifySymbol = true;
                Entity ent;
                using (Transaction tr = doc.TransactionManager.StartTransaction())
                {
                    ent = tr.GetObject(objid, OpenMode.ForWrite) as Entity;
                    if (ent == null)
                    {
                        return;
                    }
                    bakdict.Add(ent.ObjectId, ent.ColorIndex);
                    ent.ColorIndex = 4;
                    PromptSelectionResult psr;
                    Point3dCollection     p3dcc;
                    if (ent is BlockReference)
                    {
                        string[] dltArr = { "147_1", "151_1", "169_1", "173_0_0", "173_0_1" };
                        var      brf    = ent as BlockReference;
                        if (dltArr.Contains(brf.Name)) /*PublicMethod.Instance.Editor.WriteMessageWithReturn("遇上双电缆头,连接终止.\n"); */ return {
                            ;
                        }
                        var ext = ent.GeometricExtents;
                        //brf.Rotation = 0;

                        var leftup    = new Point3d(ext.MinPoint.X, ext.MaxPoint.Y, 0);
                        var leftdown  = ext.MinPoint;
                        var rightup   = ext.MaxPoint;
                        var rightdown = new Point3d(ext.MaxPoint.X, ext.MinPoint.Y, 0);
                        p3dcc = new Point3dCollection(new[] { leftup, leftdown, rightdown, rightup, leftup });
                        psr   = ed.SelectCrossingPolygon(p3dcc);
                        objs.AddRange(psr.Value.GetObjectIds());
                    }
                    else if (ent is Polyline)
                    {
                        var entpoly = ent as Polyline;
                        if (entpoly.NumberOfVertices < 2)
                        {
                            return;
                        }
                        Point3d[] startendpt = { entpoly.StartPoint, entpoly.EndPoint };
                        for (int i = 0; i < 2; i++)
                        {
                            const double lenght = 0.00000040;
                            p3dcc = new Point3dCollection(new[] {
                                new Point3d(startendpt[i].X - lenght, startendpt[i].Y + lenght, 0),
                                new Point3d(startendpt[i].X - lenght, startendpt[i].Y - lenght, 0),
                                new Point3d(startendpt[i].X + lenght, startendpt[i].Y - lenght, 0),
                                new Point3d(startendpt[i].X + lenght, startendpt[i].Y + lenght, 0),
                                new Point3d(startendpt[i].X - lenght, startendpt[i].Y + lenght, 0)
                            });
                            psr = ed.SelectCrossingPolygon(p3dcc);
                            if (psr.Status == PromptStatus.OK)
                            {
                                objs.AddRange(psr.Value.GetObjectIds());
                            }
                        }
                    }
                    tr.Commit();
                }
Пример #30
0
        /// <summary>
        /// 增加杆
        /// </summary>
        /// <param name="fid">线的FID</param>
        /// <param name="selFid">杆的FID</param>
        public static void addRole(long fid, long selFid)
        {
            // 判断杆在contain表中是否有数据
            //var role =
            //    DBManager.Instance.GetEntities<Contain_n>(
            //        o => o.G3E_FID == selFid && o.EntityState != EntityState.Delete).FirstOrDefault();
            //if (null == role)
            //{
            //    PublicMethod.Instance.AlertDialog(String.Format("Contain_n 没有此杆的数据,不能做包含关系.杆G3e_Fid = {0}\n", selFid));
            //    return;
            //}
            // 获取实体对象(线与杆)
            var _s = DBManager.Instance.GetEntity <Contain_n>(
                o => o.G3E_FID == fid &&
                o.G3E_OWNERFID == selFid &&
                o.EntityState != EntityState.Delete);

            // 判断是否已经被此杆重复包含
            if (null != _s)
            {
                PublicMethod.Instance.AlertDialog("10kV 导线已经被此杆包含.\n");
                return;
            }
            var __s = DBManager.Instance.GetEntities <Contain_n>(o => o.G3E_FID == fid && o.EntityState != EntityState.Delete);
            var _nv = new Contain_n
            {
                G3E_FNO      = 141,
                G3E_FID      = fid,
                G3E_CNO      = 38,
                G3E_ID       = CYZCommonFunc.getid(),
                G3E_OWNERFID = selFid,
                G3E_OWNERFNO = 201,
                LTT_ID       = MapConfig.Instance.LTTID,
                LTT_DATE     = null,
                LTT_STATUS   = null
            };

            if (__s.Any())
            {
                _s = __s.OrderBy(o => o.G3E_CID).Last();
                // 更改实体信息
                if (0 == _s.G3E_OWNERFID)
                {
                    if (_s.EntityState == EntityState.None)
                    {
                        _s.EntityState = EntityState.Update;
                    }
                    _s.G3E_OWNERFID = selFid;
                    _s.G3E_OWNERFNO = 201;
                    DBManager.Instance.Update(_s);
                }
                else
                {
                    _nv.G3E_CID = _s.G3E_CID + 1;
                    // 更新实体ownerid
                    _nv.EntityState = EntityState.Insert;
                    DBManager.Instance.Insert(_nv);
                }
            }
            else
            {
                _nv.G3E_CID = 1;
                // 更新实体ownerid
                _nv.EntityState = EntityState.Insert;
                DBManager.Instance.Insert(_nv);
                //DBManager.Instance.Update(_nv);
            }
        }