コード例 #1
0
        private void tsbShare_Click(object sender, EventArgs e)
        {
            if (SelectedCabelCode != Guid.Empty)
            {
                if (Atend.Base.Equipment.EContainerPackage.ShareOnServer(Convert.ToInt32(Atend.Control.Enum.ProductType.GroundCabel), SelectedCabelCode))
                {
                    Atend.Base.Equipment.EGroundCabel GroundCabel = Atend.Base.Equipment.EGroundCabel.SelectByXCode(SelectedCabelCode);
                    Code = GroundCabel.Code;
                    MessageBox.Show("به اشتراک گذاری با موفقیت انجام شد");
                }
                else
                {
                    MessageBox.Show("خطا در به اشتراک گذاری .");
                }
            }
            else
            {
                MessageBox.Show("لطفا تجهیز مورد نظر را انتخاب کنید");
            }

            //if (SelectedCabelCode != Guid.Empty)
            //{
            //    if (Atend.Base.Equipment.EGroundCabel.ShareOnServer(SelectedCabelCode))
            //    {
            //        Atend.Base.Equipment.EGroundCabel g1 = Atend.Base.Equipment.EGroundCabel.SelectByXCode(SelectedCabelCode);
            //        Code = g1.Code;
            //        MessageBox.Show("به اشتراک گذاری با موفقیت انجام شد");
            //    }
            //    else
            //        MessageBox.Show("خطا در به اشتراک گذاری . لطفاً دوباره سعی کنید");
            //}
            //else
            //    MessageBox.Show("لطفا تجهیز مورد نظر را انتخاب کنید");
        }
コード例 #2
0
        private void cboNeutralProductCode_SelectedIndexChanged(object sender, EventArgs e)
        {
            Guid XCode = new Guid(cboNeutralProductCode.SelectedValue.ToString());

            ed.WriteMessage(".SelectedValue=" + cboNeutralProductCode.SelectedValue.ToString() + "\n");
            Atend.Base.Equipment.EGroundCabel c1 = Atend.Base.Equipment.EGroundCabel.SelectByXCode(XCode);
            ed.WriteMessage("CrossSectionArea=" + c1.CrossSectionArea + "\n");
            txtNeutralCross.Text = Convert.ToString(c1.Size);
        }
コード例 #3
0
        public void BindDataToOwnControl(Guid XCode)
        {
            ClearCheckAndGrid(tvOperation, gvOperation);
            ClearCheckAndGrid(tvOperation, gvOperation);

            SelectedCabelCode = XCode;

            Atend.Base.Equipment.EGroundCabel middleGrounCabel = Atend.Base.Equipment.EGroundCabel.SelectByXCode(XCode);
            txtComment.Text = middleGrounCabel.Comment;
            Atend.Control.Common.selectedProductCode = middleGrounCabel.ProductCode;
            SelectProduct();

            txtName.Text              = middleGrounCabel.Name;
            txtMaxCurrent.Text        = Convert.ToString(Math.Round(middleGrounCabel.MaxCurrent, 8));
            txtCapacitance.Text       = Convert.ToString(Math.Round(middleGrounCabel.Capacitance, 8));
            txtResistance.Text        = Convert.ToString(Math.Round(middleGrounCabel.Resistance, 8));
            txtReactance.Text         = Convert.ToString(Math.Round(middleGrounCabel.Reactance, 8));
            txtSize.Text              = middleGrounCabel.Size.ToString();
            txtMaxCurrent1Second.Text = Convert.ToString(Math.Round(middleGrounCabel.MaxCurrent1Second, 8));
            cboVol.Text           = Convert.ToString(Math.Round(middleGrounCabel.Vol, 8));
            cboType.SelectedValue = middleGrounCabel.Type;
            tsbIsDefault.Checked  = middleGrounCabel.IsDefault;
            Code = middleGrounCabel.Code;
            //if (middleGrounCabel.NumString < 5)
            //{
            //    cboNumString.Text = middleGrounCabel.NumString.ToString();
            //}
            //else
            //{
            //    cboNumString.SelectedIndex=5;
            //}
            ed.WriteMessage("middleGrounCabel.NumString:{0}\n", middleGrounCabel.NumString);
            nudNumString.Value       = middleGrounCabel.NumString;
            txtCrossSectionArea.Text = Convert.ToString(Math.Round(middleGrounCabel.CrossSectionArea, 8));
            //if (middleGrounCabel.NumString < 5)
            //{
            //    cboCrossSectionArea.Text = middleGrounCabel.CrossSectionArea.ToString();
            //}
            //else
            //{
            //    for (int i = 0; i < CrossSectionValue1.Length; i++)
            //    {
            //        if (CrossSectionValue1[i].ToString() == middleGrounCabel.CrossSectionArea.ToString())
            //        {
            //            cboCrossSectionArea.SelectedIndex = i;
            //        }
            //    }
            //}
            BindTreeViwAndGrid();
        }
コード例 #4
0
        private void btnOk_Click(object sender, EventArgs e)
        {
            if (gvConductor.SelectedRows.Count > 0)
            {
                Atend.Base.Equipment.EGroundCabel GC = Atend.Base.Equipment.EGroundCabel.AccessSelectByCode(GCCode);

                Atend.Base.Design.DBranch Branch = Atend.Base.Design.DBranch.AccessSelectByCode(BranchCode);// SelectByCode(BranchCode);

                Branch.ProductCode = Convert.ToInt32(gvConductor.SelectedRows[0].Cells[0].Value.ToString());
                //if (Branch.AccessUpdate())
                //{
                //    //ed.WriteMessage("OK");
                //    //Atend.Base.Acad.AT_INFO
                //    GCCode = Convert.ToInt32(gvConductor.SelectedRows[0].Cells[0].Value.ToString());
                //    AllowClose = true;
                //    this.Close();
                //}
                //else
                //    MessageBox.Show("انجام ويرايش امكانپذير نيست");
            }
        }
コード例 #5
0
        private void cboPhaseProductCode_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (cboPhaseProductCode.Items.Count > 0)
            {
                Guid XCode = new Guid(cboPhaseProductCode.SelectedValue.ToString());
                //ed.WriteMessage(".SelectedValue=" + cboPhaseProductCode.SelectedValue.ToString() + "\n");
                Atend.Base.Equipment.EGroundCabel c1 = Atend.Base.Equipment.EGroundCabel.SelectByXCode(XCode);
                //ed.WriteMessage("CrossSectionArea=" + c1.CrossSectionArea + "\n");
                txtPhaseCross.Text = Convert.ToString(c1.Size);
                if (c1.Type == 1)
                {
                    txtType.Text = "XLPE از جنس آلمینیوم با عایق خشک";
                }

                if (c1.Type == 2)
                {
                    txtType.Text = "XLPE از جنس مس با عایق خشک";
                }

                if (c1.Type == 3)
                {
                    txtType.Text = "PVC از جنس آلمینیوم با عایق خشک";
                }

                if (c1.Type == 4)
                {
                    txtType.Text = "PVC از جنس مس با عایق خشک";
                }
            }
            //byte mat = Convert.ToByte(c1.MaterialCode.ToString());
            //Atend.Base.Equipment.EGroundCabelMaterialType m1 = Atend.Base.Equipment.EGroundCabelMaterialType.SelectByCode(mat);
            //lblMaterialCode.Text = m1.Name;
            //switch (c1.TypeCode)
            //{
            //    case 0: { lblMaterialCode.Text = "CU"; break; }
            //    case 1: { lblMaterialCode.Text = "AAC"; break; }
            //    case 2: { lblMaterialCode.Text = "ACSR"; break; }
            //    case 3: { lblMaterialCode.Text = "AAAC"; break; }
            //}
        }
コード例 #6
0
 private bool CheckStatuseOfAccessChangeDefault()
 {
     Autodesk.AutoCAD.EditorInput.Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
     //ed.WriteMessage("AccessChangeDefault={0}\n", Atend.Control.Common.AccessChangeDefault);
     if (!Atend.Control.Common.AccessChangeDefault)
     {
         if (SelectedCabelCode == Guid.Empty && IsDefault)
         {
             MessageBox.Show("کاربر گرامی شما اجازه ثبت تجهیز به صورت پیش فرض ندارید", "خطا");
             return(false);
         }
         else
         {
             Atend.Base.Equipment.EGroundCabel Equip = Atend.Base.Equipment.EGroundCabel.SelectByXCode(SelectedCabelCode);
             if (Equip.IsDefault || IsDefault)
             {
                 MessageBox.Show("کاربر گرامی شما اجازه ویرایش  تجهیز به صورت پیش فرض ندارید", "خطا");
                 return(false);
             }
         }
     }
     return(true);
 }
コード例 #7
0
        private void gvConsolsTip_Click(object sender, EventArgs e)
        {
            //tvConsolSubEquipment.Nodes.Clear();

            //int Type = (int)Atend.Control.Enum.ProductType.Consol;
            //int ContainerCode = Convert.ToInt32(gvConsolsTip.SelectedRows[0].Cells[0].Value);

            //ed.WriteMessage("Row Code is : " + ContainerCode + "\n");
            //Atend.Base.Equipment.EContainerPackage ContainerPackage = Atend.Base.Equipment.EContainerPackage.selectByContainerCodeAndType(ContainerCode, Type);
            //ed.WriteMessage("Row Code in EContainerPackage is : " + ContainerPackage.Code + "\n");


            //DataTable ProductPackageTable = Atend.Base.Equipment.EProductPackage.SelectByContainerPackageCode(ContainerPackage.Code);
            //ed.WriteMessage(string.Format("RowCount in productPackage : {0} \n", ProductPackageTable.Rows.Count));

            //foreach (DataRow row in ProductPackageTable.Rows)
            //{

            //    #region find each row TableType
            //    byte TableType = Convert.ToByte(row["TableType"]);
            //    #endregion
            //    ed.WriteMessage(string.Format("TableType : {0} \n", TableType));

            //    #region search in XML for Table of TableType value
            //    string Table = DetermineTableValue(TableType);
            //    #endregion

            //    ed.WriteMessage(string.Format("Table : {0} \n", Table));

            //    if (Table == "Self")
            //    {
            //        switch ((Atend.Control.Enum.ProductType)TableType)
            //        {
            //            case Atend.Control.Enum.ProductType.Insulator:

            //                ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
            //                Atend.Base.Equipment.EInsulator insulator = Atend.Base.Equipment.EInsulator.SelectByCode(Convert.ToInt32(row["ProductCode"]));
            //                tvConsolSubEquipment.Nodes.Add(insulator.Name);

            //                break;
            //            case Atend.Control.Enum.ProductType.InsulatorChain:

            //                break;
            //            case Atend.Control.Enum.ProductType.InsulatorPipe:
            //                break;
            //        }
            //    }
            //    else
            //    {
            //        ed.WriteMessage("second productCode : " + Convert.ToInt32(row["ProductCode"]).ToString());
            //        Atend.Base.Base.BProduct product = Atend.Base.Base.BProduct.Select_ByCode(Convert.ToInt32(row["ProductCode"]));
            //        tvConsolSubEquipment.Nodes.Add(product.Name);
            //    }
            //}

            /////////////////////////////////////////////////////////////////////

            if (gvConsolsTip.Rows.Count > 0)
            {
                tvConsolSubEquipment.Nodes.Clear();

                int Type          = (int)Atend.Control.Enum.ProductType.Consol;
                int ContainerCode = Convert.ToInt32(gvConsolsTip.SelectedRows[0].Cells[0].Value);

                //ed.WriteMessage("Row Code is : " + ContainerCode + "\n");
                //Atend.Base.Equipment.EContainerPackage ContainerPackage = Atend.Base.Equipment.EContainerPackage.selectByContainerCodeAndType(ContainerCode, Type);
                //ed.WriteMessage("Row Code in EContainerPackage is : " + ContainerPackage.Code + "\n");


                DataTable ProductPackageTable = Atend.Base.Equipment.EProductPackage.SelectByContainerCodeAndType(ContainerCode, Type);
                //ed.WriteMessage(string.Format("RowCount in productPackage : {0} \n", ProductPackageTable.Rows.Count));

                foreach (DataRow row in ProductPackageTable.Rows)
                {
                    #region find each row TableType
                    byte TableType = Convert.ToByte(row["TableType"]);
                    #endregion
                    //ed.WriteMessage(string.Format("TableType : {0} \n", TableType));

                    #region search in XML for Table of TableType value
                    string Table = DetermineTableValue(TableType);
                    #endregion

                    //ed.WriteMessage(string.Format("Table : {0} \n", Table));

                    if (Table == "Self")
                    {
                        switch ((Atend.Control.Enum.ProductType)TableType)
                        {
                        case Atend.Control.Enum.ProductType.Insulator:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EInsulator insulator = Atend.Base.Equipment.EInsulator.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(insulator.Name);

                            break;

                        case Atend.Control.Enum.ProductType.AirPost:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EAirPost airPost = Atend.Base.Equipment.EAirPost.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(airPost.Name);
                            break;
                        //case Atend.Control.Enum.ProductType.AuoKey3p:

                        //    //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.EAutoKey_3p autokey3p = Atend.Base.Equipment.EAutoKey_3p.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(autokey3p.Name);
                        //    break;

                        case Atend.Control.Enum.ProductType.Breaker:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EBreaker breaker = Atend.Base.Equipment.EBreaker.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(breaker.Name);
                            break;
                        //case Atend.Control.Enum.ProductType.Bus:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.EBus bus = Atend.Base.Equipment.EBus.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(conductor.Name);
                        //    break;
                        case Atend.Control.Enum.ProductType.GroundCabel:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EGroundCabel cabel = Atend.Base.Equipment.EGroundCabel.AccessSelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(cabel.Name);
                            break;

                        case Atend.Control.Enum.ProductType.CatOut:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.ECatOut catout = Atend.Base.Equipment.ECatOut.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(catout.Name);
                            break;

                        case Atend.Control.Enum.ProductType.Conductor:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EConductor conductor = Atend.Base.Equipment.EConductor.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(conductor.Name);
                            break;

                        case Atend.Control.Enum.ProductType.Consol:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EConsol consol = Atend.Base.Equipment.EConsol.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(consol.Name);
                            break;
                        //case Atend.Control.Enum.ProductType.Countor:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.ECountor counter = Atend.Base.Equipment.ECountor.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(counter.Name);
                        //    break;
                        //case Atend.Control.Enum.ProductType.CT:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.ECT ct = Atend.Base.Equipment.ECT.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(ct.Name);
                        //    break;
                        //case Atend.Control.Enum.ProductType.DB:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.EDB db = Atend.Base.Equipment.EDB.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(db.Name);
                        //    break;
                        case Atend.Control.Enum.ProductType.Disconnector:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EDisconnector disconnector = Atend.Base.Equipment.EDisconnector.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(disconnector.Name);
                            break;

                        case Atend.Control.Enum.ProductType.GroundPost:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EGroundPost groundPost = Atend.Base.Equipment.EGroundPost.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(groundPost.Name);
                            break;

                        case Atend.Control.Enum.ProductType.HeaderCabel:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EHeaderCabel headerCabel = Atend.Base.Equipment.EHeaderCabel.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(headerCabel.Name);
                            break;

                        case Atend.Control.Enum.ProductType.Jumper:
//Extra
                        ////ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //Atend.Base.Equipment.EJumper jumper = Atend.Base.Equipment.EJumper.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //tvConsolSubEquipment.Nodes.Add(jumper.Name);
                        //break;
                        case Atend.Control.Enum.ProductType.Khazan:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EKhazan khzan = Atend.Base.Equipment.EKhazan.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(khzan.Name);
                            break;

                        case Atend.Control.Enum.ProductType.Mafsal:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EMafsal mafsal = Atend.Base.Equipment.EMafsal.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(mafsal.Name);
                            break;
                        //case Atend.Control.Enum.ProductType.PhotoCell:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.EPhotoCell phtoCell = Atend.Base.Equipment.EPhotoCell.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(phtoCell.Name);
                        //    break;
                        case Atend.Control.Enum.ProductType.Pole:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EPole pole = Atend.Base.Equipment.EPole.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(pole.Name);
                            break;
                        //case Atend.Control.Enum.ProductType.PT:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.EPT pt = Atend.Base.Equipment.EPT.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(pt.Name);
                        //    break;
                        //case Atend.Control.Enum.ProductType.ReCloser:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.EReCloser recloser = Atend.Base.Equipment.EReCloser.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(recloser.Name);
                        //    break;
                        case Atend.Control.Enum.ProductType.Rod:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.ERod rod = Atend.Base.Equipment.ERod.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(rod.Name);
                            break;
                        //case Atend.Control.Enum.ProductType.SectionLizer:

                        //    ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                        //    Atend.Base.Equipment.ESectionLizer sectionLizer = Atend.Base.Equipment.ESectionLizer.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                        //    tvConsolSubEquipment.Nodes.Add(sectionLizer.Name);
                        //    break;
                        case Atend.Control.Enum.ProductType.StreetBox:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.EStreetBox streetBox = Atend.Base.Equipment.EStreetBox.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(streetBox.Name);
                            break;

                        case Atend.Control.Enum.ProductType.Transformer:

                            //ed.WriteMessage("first productCode : " + Convert.ToInt32(row["ProductCode"]));
                            Atend.Base.Equipment.ETransformer transform = Atend.Base.Equipment.ETransformer.SelectByCode(Convert.ToInt32(row["ProductCode"]));
                            tvConsolSubEquipment.Nodes.Add(transform.Name);
                            break;

                        case Atend.Control.Enum.ProductType.InsulatorChain:

                            break;

                        case Atend.Control.Enum.ProductType.InsulatorPipe:
                            break;
                        }
                    }
                    else
                    {
                        //ed.WriteMessage("second productCode : " + Convert.ToInt32(row["ProductCode"]).ToString());
                        Atend.Base.Base.BProduct product = Atend.Base.Base.BProduct.Select_ByCode(Convert.ToInt32(row["ProductCode"]));
                        tvConsolSubEquipment.Nodes.Add(product.Name);
                    }
                }
            }

            /////////////////////////////////////////////////////////////////////
        }
コード例 #8
0
        private void btnOk_Click(object sender, EventArgs e)
        {
            if (Validation())
            {
                if (Convert.ToBoolean(gvConductor.Rows[gvConductor.CurrentRow.Index].Cells[2].Value) == false)//Access
                {
                    Atend.Base.Equipment.EGroundCabelTip GroundCabelTip = Atend.Base.Equipment.EGroundCabelTip.AccessSelectByCode(Convert.ToInt32(gvConductor.Rows[gvConductor.CurrentRow.Index].Cells[1].Value.ToString()));
                    if (GroundCabelTip.Code != -1)
                    {
                        Atend.Base.Acad.AcadGlobal.GroundCableData.eGroundCabelTip = GroundCabelTip;
                        Atend.Base.Acad.AcadGlobal.GroundCableData.UseAccess       = true;

                        Atend.Base.Equipment.EGroundCabel GroundPhase = Atend.Base.Equipment.EGroundCabel.AccessSelectByCode(GroundCabelTip.PhaseProductCode);
                        if (GroundPhase.Code != -1)
                        {
                            Atend.Base.Acad.AcadGlobal.GroundCableData.eGroundCabels.Add(GroundPhase);
                            Atend.Base.Equipment.EGroundCabel GroundNeutral = Atend.Base.Equipment.EGroundCabel.AccessSelectByCode(GroundCabelTip.NeutralProductCode);
                            if (GroundNeutral.Code != -1)
                            {
                                Atend.Base.Acad.AcadGlobal.GroundCableData.eGroundCabels.Add(GroundNeutral);
                            }
                            else
                            {
                                return;
                            }
                        }
                        else
                        {
                            return;
                        }
                    }
                    else
                    {
                        return;
                    }
                }
                else
                {
                    Atend.Base.Equipment.EGroundCabelTip GroundCabelTip = Atend.Base.Equipment.EGroundCabelTip.SelectByXCode(new Guid(gvConductor.Rows[gvConductor.CurrentRow.Index].Cells[0].Value.ToString()));
                    if (GroundCabelTip.Code != -1)
                    {
                        Atend.Base.Acad.AcadGlobal.GroundCableData.eGroundCabelTip = GroundCabelTip;
                        Atend.Base.Acad.AcadGlobal.GroundCableData.UseAccess       = false;

                        Atend.Base.Equipment.EGroundCabel GroundPhase = Atend.Base.Equipment.EGroundCabel.SelectByXCode(GroundCabelTip.PhaseProductXCode);
                        if (GroundPhase.Code != -1)
                        {
                            Atend.Base.Acad.AcadGlobal.GroundCableData.eGroundCabels.Add(GroundPhase);

                            Atend.Base.Equipment.EGroundCabel GroundNeutral = Atend.Base.Equipment.EGroundCabel.SelectByXCode(GroundCabelTip.NeutralProductXCode);
                            if (GroundNeutral.Code != -1)
                            {
                                Atend.Base.Acad.AcadGlobal.GroundCableData.eGroundCabels.Add(GroundNeutral);
                            }
                            else
                            {
                                return;
                            }
                        }
                        else
                        {
                            return;
                        }
                    }
                    else
                    {
                        return;
                    }
                }

                Atend.Base.Base.BEquipStatus status = Atend.Base.Base.BEquipStatus.SelectByCode(Convert.ToInt32(cboIsExist.SelectedValue));
                Atend.Base.Acad.AcadGlobal.GroundCableData.Existance = status.ACode;

                if (cboProjCode.Items.Count == 0)
                {
                    Atend.Base.Acad.AcadGlobal.GroundCableData.ProjectCode = 0;
                }
                else
                {
                    Atend.Base.Acad.AcadGlobal.GroundCableData.ProjectCode = Convert.ToInt32(cboProjCode.SelectedValue);
                }

                Atend.Control.Common.IsExist = Convert.ToInt32(cboIsExist.SelectedValue.ToString());
                if (cboProjCode.Items.Count != 0)
                {
                    Atend.Control.Common.ProjectCode = Convert.ToInt32(cboProjCode.SelectedValue.ToString());
                }
                else
                {
                    Atend.Control.Common.ProjectCode = -1;
                }

                AllowClose = true;
            }
            else
            {
                AllowClose = false;
            }
        }
コード例 #9
0
        public bool ChangeBranchInfo()
        {
            OleDbConnection  conection = new OleDbConnection(Atend.Control.ConnectionString.AccessCnString);
            OleDbTransaction transaction;
            Editor           ed = Application.DocumentManager.MdiActiveDocument.Editor;

            try
            {
                conection.Open();
                transaction = conection.BeginTransaction();
                try
                {
                    int ConductorCounter   = 0;
                    int SelfkeeperCounter  = 0;
                    int GroundCabelCounter = 0;

                    foreach (Atend.Base.Design.DBranch branch in dBranch)
                    {
                        ObjectId obj = Atend.Global.Acad.UAcad.GetBranchByGuid(branch.Code);
                        Atend.Base.Acad.AT_INFO atInfo = Atend.Base.Acad.AT_INFO.SelectBySelectedObjectId(obj);

                        #region Conductor
                        if (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.Conductor))
                        {
                            Atend.Base.Equipment.EConductor CondPhase   = Atend.Base.Equipment.EConductor.SelectByXCode(CondTip[ConductorCounter].PhaseProductXCode);
                            Atend.Base.Equipment.EConductor CondNeutral = Atend.Base.Equipment.EConductor.SelectByXCode(CondTip[ConductorCounter].NeutralProductXCode);
                            Atend.Base.Equipment.EConductor CondNight   = Atend.Base.Equipment.EConductor.SelectByXCode(CondTip[ConductorCounter].NightProductXCode);

                            if (!CondPhase.AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Failed");
                            }

                            if (!CondNeutral.AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Failed");
                            }
                            if (!CondNight.AccessInsert(transaction, conection, true, true))
                            {
                            }
                            CondTip[ConductorCounter].PhaseProductCode   = CondPhase.Code;
                            CondTip[ConductorCounter].NeutralProductCode = CondNeutral.Code;
                            CondTip[ConductorCounter].NightProductCode   = CondNight.Code;

                            if (!CondTip[ConductorCounter].AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Tip Failed");
                            }

                            branch.ProductCode = CondTip[ConductorCounter].Code;
                            branch.Number      = CondTip[ConductorCounter].Description;
                            atInfo.ProductCode = condTip[ConductorCounter].Code;
                            if (branch.AccessUpdate(transaction, conection))
                            {
                                Atend.Global.Acad.DrawEquips.AcDrawConductor.ChangeCounductorComment(obj, CondTip[ConductorCounter].Description);
                                atInfo.Insert();
                            }
                            else
                            {
                                throw new System.Exception("Insert Branch Failed");
                            }
                            ConductorCounter++;
                        }
                        #endregion


                        #region SelfKeeper
                        if (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.SelfKeeper))
                        {
                            Atend.Base.Equipment.ESelfKeeper SelfPhase   = Atend.Base.Equipment.ESelfKeeper.SelectByXCode(SelfTip[SelfkeeperCounter].PhaseProductxCode);
                            Atend.Base.Equipment.ESelfKeeper SelfNeutral = Atend.Base.Equipment.ESelfKeeper.SelectByXCode(SelfTip[SelfkeeperCounter].NeutralProductxCode);
                            Atend.Base.Equipment.ESelfKeeper SelfNight   = Atend.Base.Equipment.ESelfKeeper.SelectByXCode(SelfTip[SelfkeeperCounter].NightProductxCode);

                            if (!SelfPhase.AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Failed");
                            }

                            if (!SelfNeutral.AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Failed");
                            }
                            if (!SelfNight.AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Failed");
                            }
                            SelfTip[SelfkeeperCounter].PhaseProductCode   = SelfPhase.Code;
                            SelfTip[SelfkeeperCounter].NeutralProductCode = SelfNeutral.Code;
                            SelfTip[SelfkeeperCounter].NightProductCode   = SelfNight.Code;

                            if (!SelfTip[SelfkeeperCounter].AccessInsert(transaction, conection))
                            {
                                throw new System.Exception("Insert Tip Failed");
                            }

                            branch.ProductCode = SelfTip[SelfkeeperCounter].Code;
                            branch.Number      = SelfTip[SelfkeeperCounter].Description;
                            atInfo.ProductCode = SelfTip[SelfkeeperCounter].Code;

                            if (branch.AccessUpdate(transaction, conection))
                            {
                                Atend.Global.Acad.DrawEquips.AcDrawSelfKeeper.ChangeCabelComment(obj, SelfTip[SelfkeeperCounter].Description);
                                atInfo.Insert();
                            }
                            else
                            {
                                throw new System.Exception("Insert Branch Failed");
                            }

                            SelfkeeperCounter++;
                        }
                        #endregion


                        #region GroundCabel
                        if (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.GroundCabel))
                        {
                            Atend.Base.Equipment.EGroundCabel GroundPhase   = Atend.Base.Equipment.EGroundCabel.SelectByXCode(GroundTip[GroundCabelCounter].PhaseProductXCode);
                            Atend.Base.Equipment.EGroundCabel GroundNeutral = Atend.Base.Equipment.EGroundCabel.SelectByXCode(GroundTip[GroundCabelCounter].NeutralProductXCode);
                            //Atend.Base.Equipment.EGroundCabel GroundNight = Atend.Base.Equipment.EGroundCabel.SelectByXCode(GroundTip[GroundCabelCounter].NightProductxCode);

                            if (!GroundPhase.AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Failed");
                            }

                            if (!GroundNeutral.AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Failed");
                            }
                            //if (!GroundNight.AccessInsert(transaction, conection, true, true))
                            //{
                            //    throw new System.Exception("Insert Failed");

                            //}
                            GroundTip[GroundCabelCounter].PhaseProductCode   = GroundPhase.Code;
                            GroundTip[GroundCabelCounter].NeutralProductCode = GroundNeutral.Code;
                            //GroundTip[GroundCabelCounter].NightProductCode = GroundNight.Code;

                            if (!GroundTip[GroundCabelCounter].AccessInsert(transaction, conection, true, true))
                            {
                                throw new System.Exception("Insert Tip Failed");
                            }

                            branch.ProductCode = GroundTip[GroundCabelCounter].Code;
                            branch.Number      = GroundTip[GroundCabelCounter].Description;
                            atInfo.ProductCode = GroundTip[GroundCabelCounter].Code;
                            if (branch.AccessUpdate(transaction, conection))
                            {
                                Atend.Global.Acad.DrawEquips.AcDrawGroundCabel.ChangeCabelComment(obj, GroundTip[GroundCabelCounter].Description);
                                atInfo.Insert();
                            }
                            else
                            {
                                throw new System.Exception("Insert Branch Failed");
                            }
                            GroundCabelCounter++;
                        }
                        #endregion
                    }
                }
                catch (System.Exception ex)
                {
                    ed.WriteMessage("Error In 01={0}\n", ex.Message);
                    transaction.Rollback();
                    conection.Close();
                    return(false);
                }
            }
            catch (System.Exception ex1)
            {
                ed.WriteMessage("Error in 02={0}\n", ex1.Message);
                conection.Close();
                return(false);
            }
            transaction.Commit();
            conection.Close();
            return(true);
        }
コード例 #10
0
        //DataColumn dcSCCurrent = new DataColumn("SCCurrent");
        //DataColumn CondMax1sCurrent = new DataColumn("CondMax1sCurrent");

        public frmElectericalResult(DataTable dtNodes, DataTable dtBranch)
        {
            Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;

            ed.WriteMessage("\nchecking.....\n");
            if (!Atend.Global.Acad.DrawEquips.Dicision.IsHere())
            {
                if (!Atend.Global.Acad.DrawEquips.Dicision.IsThere())
                {
                    //System.Diagnostics.Process[] prs = System.Diagnostics.Process.GetProcesses();
                    //foreach (System.Diagnostics.Process pr in prs)
                    //{
                    //    if (pr.ProcessName == "acad")
                    //    {
                    //        pr.CloseMainWindow();
                    //    }
                    //}
                    Atend.Global.Acad.Notification notification = new Atend.Global.Acad.Notification();
                    notification.Title = "شناسایی قفل";
                    notification.Msg   = "لطفا وضعیت قفل را بررسی نمایید ";
                    notification.infoCenterBalloon();

                    ForceToClose = true;
                }
            }
            InitializeComponent();

            dtResultNode.Columns.Add(dcLoadPowerImage);
            dtResultNode.Columns.Add(dcLoadPowerReal);
            dtResultNode.Columns.Add(dcVoltAbs);
            dtResultNode.Columns.Add(dcVoltAng);
            dtResultNode.Columns.Add(dcVoltDropPer);
            dtResultNode.Columns.Add(dcLoadCurrentAbs);
            dtResultNode.Columns.Add(dcLoadCurrentArg);
            dtResultNode.Columns.Add(dcConsolGuid);

            dtResultBranch.Columns.Add(dcCode);
            dtResultBranch.Columns.Add(dcCondUtilization);
            dtResultBranch.Columns.Add(dcLenght);
            dtResultBranch.Columns.Add(dcCurrentAbs);
            dtResultBranch.Columns.Add(dcCurrentAng);
            dtResultBranch.Columns.Add(dcTotalLoadREal);
            dtResultBranch.Columns.Add(dcCondCode);
            dtResultBranch.Columns.Add(dcCondCurrent);
            dtResultBranch.Columns.Add(dcFrom);
            dtResultBranch.Columns.Add(dcTo);
            dtResultBranch.Columns.Add(dcPowerLoss);
            //dtResultBranch.Columns.Add(dcSCCurrent);
            //dtResultBranch.Columns.Add(CondMax1sCurrent);

            //ed.WriteMessage("Print Nodes\n");

            Atend.Base.Calculating.CDistributedLoadBranch.AccessDelete();
            Atend.Base.Calculating.CDistributedLoadNode.AccessDelete();

            foreach (DataRow dr in dtNodes.Rows)
            {
                DataRow drNew = dtResultNode.NewRow();
                Atend.Base.Calculating.CDistributedLoadNode loadNode = new Atend.Base.Calculating.CDistributedLoadNode();

                Atend.Base.Design.DPackage pack = Atend.Base.Design.DPackage.AccessSelectByCode(new Guid(dr["ConsoleGuid"].ToString()));
                if (pack.Code != Guid.Empty)
                {
                    drNew["ConsolGuid"] = pack.Number;
                    loadNode.NodeName   = pack.Number;

                    drNew["VoltAbs"] = Math.Round(((Complex)dr["Voltage"]).abs, 3);
                    loadNode.VoltAbs = Math.Round(((Complex)dr["Voltage"]).abs, 3);
                    double voltDegree = ConvertToDegree(((Complex)dr["Voltage"]).arg);
                    //drNew["VoltArg"] = Math.Round(((Complex)dr["Voltage"]).arg, 2);
                    //loadNode.VoltArg = Math.Round(((Complex)dr["Voltage"]).arg, 2);

                    drNew["VoltArg"] = Math.Round(voltDegree, 2);
                    loadNode.VoltArg = Math.Round(voltDegree, 2);

                    double voltDropPer = 100 - Convert.ToDouble(dr["VoltageDropPer"].ToString());

                    drNew["VoltDropPer"] = Math.Round(voltDropPer, 2);
                    loadNode.DropVolt    = Convert.ToDouble(Math.Round(voltDropPer, 2));

                    drNew["LoadPowerReal"] = Math.Round(((Complex)dr["LoadPower"]).imag, 3) / 1000;
                    loadNode.LoadPower     = Math.Round(((Complex)dr["LoadPower"]).imag, 3) / 1000;


                    drNew["LoadPowerImg"]    = Math.Round(((Complex)dr["LoadPower"]).real, 3) / 1000;
                    loadNode.LoadPowerActive = Math.Round(((Complex)dr["LoadPower"]).real, 3) / 1000;

                    drNew["LoadCurrentAbs"] = Math.Round(((Complex)dr["LoadCurrent"]).abs, 3);//.ToString();
                    loadNode.LoadCurrentAbs = Math.Round(((Complex)dr["LoadCurrent"]).abs, 3);


                    double LoadCurrentArg = ConvertToDegree(((Complex)dr["LoadCurrent"]).arg);
                    //drNew["LoadCurrentArg"] = Math.Round(((Complex)dr["LoadCurrent"]).arg, 3);
                    //loadNode.LoadCurrentArg = Math.Round(((Complex)dr["LoadCurrent"]).arg, 3);


                    drNew["LoadCurrentArg"] = Math.Round(LoadCurrentArg, 3);
                    loadNode.LoadCurrentArg = Math.Round(LoadCurrentArg, 3);

                    dtResultNode.Rows.Add(drNew);

                    if (!loadNode.AccessInsert())
                    {
                        ed.WriteMessage("LoadNode Insert Failed\n");
                    }
                }
            }
            //ed.WriteMessage("Print Branch\n");
            double totalLoad = 0;

            foreach (DataRow dr in dtBranch.Rows)
            {
                DataRow drNew = dtResultBranch.NewRow();
                Atend.Base.Calculating.CDistributedLoadBranch LoadBranch = new Atend.Base.Calculating.CDistributedLoadBranch();
                Atend.Base.Design.DBranch branch = Atend.Base.Design.DBranch.AccessSelectByCode(new Guid(dr["Code"].ToString()));

                if (branch.Code != Guid.Empty)
                {
                    drNew["Code"]         = branch.Number;
                    LoadBranch.BranchName = branch.Number;

                    drNew["Lenght"]   = Math.Round(Convert.ToDouble(dr["Length"].ToString()), 2);
                    LoadBranch.Lenght = Math.Round(Convert.ToDouble(dr["Length"].ToString()), 3);

                    drNew["CondUtilization"]   = Math.Round(Convert.ToDouble(dr["CondUtilization"].ToString()), 3);
                    LoadBranch.Condutilization = Math.Round(Convert.ToDouble(dr["CondUtilization"].ToString()), 3);

                    drNew["CurrentAbs"]   = Math.Round(((Complex)dr["Current"]).abs, 3);//.ToString();
                    LoadBranch.CurrentAbs = Math.Round(((Complex)dr["Current"]).abs, 3);


                    double currentArg = ConvertToDegree(((Complex)dr["Current"]).arg);
                    //drNew["CurrentArg"] = Math.Round(((Complex)dr["Current"]).arg, 3);
                    //LoadBranch.CurrentArg = Math.Round(((Complex)dr["Current"]).arg, 3);
                    drNew["CurrentArg"]   = Math.Round(currentArg, 3);
                    LoadBranch.CurrentArg = Math.Round(currentArg, 3);

                    //MessageBox.Show(dr["PowerLoss"].ToString());


                    totalLoad += Math.Round(((Complex)dr["TotalLoad"]).real / 1000 + (Convert.ToDouble(dr["PowerLoss"].ToString()) / 1000), 3);
                    drNew["TotalLoadReal"] = totalLoad;
                    LoadBranch.TotalLoad   = totalLoad;//Math.Round(((Complex)dr["TotalLoad"]).real / 1000 + (Convert.ToDouble(dr["PowerLoss"].ToString()) / 1000), 3);


                    ed.WriteMessage("CondCode={0}\n", dr["CondCode"].ToString());

                    if ((branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.Conductor)) || (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.Jumper)) || (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.Terminal)))
                    {
                        Atend.Base.Equipment.EConductorTip econdTip = Atend.Base.Equipment.EConductorTip.AccessSelectByCode(branch.ProductCode);
                        Atend.Base.Equipment.EConductor    eCond    = Atend.Base.Equipment.EConductor.AccessSelectByCode(econdTip.PhaseProductCode);

                        drNew["CondName"]    = eCond.Name;
                        drNew["CondCurrent"] = eCond.MaxCurrent;

                        LoadBranch.CondName    = eCond.Name;
                        LoadBranch.CondCurrent = eCond.MaxCurrent;
                    }
                    else if (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.SelfKeeper))
                    {
                        Atend.Base.Equipment.ESelfKeeperTip eSelTip = Atend.Base.Equipment.ESelfKeeperTip.AccessSelectByCode(branch.ProductCode);
                        Atend.Base.Equipment.ESelfKeeper    eSelf   = Atend.Base.Equipment.ESelfKeeper.AccessSelectByCode(eSelTip.PhaseProductCode);

                        drNew["CondName"]    = eSelf.Name;
                        drNew["CondCurrent"] = eSelf.MaxCurrent;

                        LoadBranch.CondName    = eSelf.Name;
                        LoadBranch.CondCurrent = eSelf.MaxCurrent;
                    }
                    else if (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.GroundCabel))
                    {
                        Atend.Base.Equipment.EGroundCabelTip egroundTip = Atend.Base.Equipment.EGroundCabelTip.AccessSelectByCode(branch.ProductCode);
                        Atend.Base.Equipment.EGroundCabel    eGround    = Atend.Base.Equipment.EGroundCabel.AccessSelectByCode(egroundTip.PhaseProductCode);

                        drNew["CondName"]    = eGround.Name;
                        drNew["CondCurrent"] = eGround.MaxCurrent;

                        LoadBranch.CondName    = eGround.Name;
                        LoadBranch.CondCurrent = eGround.MaxCurrent;
                    }

                    DataRow[] drnodeFrom = dtNodes.Select(string.Format("ConsoleObjID={0}", dr["UpNodeId"].ToString()));
                    if (drnodeFrom.Length > 0)
                    {
                        drNew["From"]   = FindNodeComment(new Guid(drnodeFrom[0]["ConsoleGuid"].ToString()));
                        LoadBranch.From = drNew["From"].ToString();
                    }


                    //به
                    DataRow[] drnodeTo = dtNodes.Select(string.Format("ConsoleObjID={0}", dr["DnNodeId"].ToString()));
                    if (drnodeTo.Length > 0)
                    {
                        //drNew["Volt"] = Math.Round(((Complex)(drnodeTo[0]["Voltage"])).abs, 2).ToString();
                        drNew["To"]   = FindNodeComment(new Guid(drnodeTo[0]["ConsoleGuid"].ToString()));
                        LoadBranch.To = drNew["To"].ToString();
                    }
                    LoadBranch.PowerLoss = Math.Round(Convert.ToDouble(dr["PowerLoss"]) / 1000, 2);
                    drNew["PowerLoss"]   = Math.Round(Convert.ToDouble(dr["PowerLoss"]) / 1000, 2);



                    dtResultBranch.Rows.Add(drNew);
                    if (!LoadBranch.AccessInsert())
                    {
                        ed.WriteMessage("LoadBranch Inser Failed\n");
                    }
                }
                //drNew["SCCurrent"] = Math.Round(Convert.ToDouble(dr["SCCurrent"].ToString()), 3);
                //drNew["CondMax1sCurrent"] = Math.Round(Convert.ToDouble(dr["CondMax1sCurrent"].ToString()), 3);
            }
            //ed.WriteMessage("BindDAtA\n");
            //string Code1 = "00000000-0000-0000-0000-000000000000";
            //DataRow[] drs = dtResultBranch.Select(" Code= '" + Code1 + "'");
            //drs[0].Delete();

            //DataRow[] drs1 = dtResultNode.Select(" ConsolGuid ='" + Code1 + "'");
            //drs1[0].Delete();

            gvBranch.AutoGenerateColumns = false;
            gvBranch.DataSource          = dtResultBranch;

            gvNode.AutoGenerateColumns = false;
            gvNode.DataSource          = dtResultNode;
        }
コード例 #11
0
        public frmShortCircuitResult(DataTable dtNodes, DataTable dtBranch, double FalutDuration)
        {
            Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;

            ed.WriteMessage("\nchecking.....\n");
            if (!Atend.Global.Acad.DrawEquips.Dicision.IsHere())
            {
                if (!Atend.Global.Acad.DrawEquips.Dicision.IsThere())
                {
                    //System.Diagnostics.Process[] prs = System.Diagnostics.Process.GetProcesses();
                    //foreach (System.Diagnostics.Process pr in prs)
                    //{
                    //    if (pr.ProcessName == "acad")
                    //    {
                    //        pr.CloseMainWindow();
                    //    }
                    //}
                    Atend.Global.Acad.Notification notification = new Atend.Global.Acad.Notification();
                    notification.Title = "شناسایی قفل";
                    notification.Msg   = "لطفا وضعیت قفل را بررسی نمایید ";
                    notification.infoCenterBalloon();

                    ForceToClose = true;
                }
            }

            InitializeComponent();
            _FaultDuration = FalutDuration;
            dtResultNode.Columns.Add(dcLoadPowerImage);
            dtResultNode.Columns.Add(dcLoadPowerReal);
            dtResultNode.Columns.Add(dcVoltAbs);
            dtResultNode.Columns.Add(dcVoltAng);
            dtResultNode.Columns.Add(dcVoltDropPer);
            dtResultNode.Columns.Add(dcLoadCurrentAbs);
            dtResultNode.Columns.Add(dcLoadCurrentArg);
            dtResultNode.Columns.Add(dcConsolGuid);

            dtResultBranch.Columns.Add(dcCode);
            dtResultBranch.Columns.Add(dcCondUtilization);
            dtResultBranch.Columns.Add(dcLenght);
            dtResultBranch.Columns.Add(dcCurrentAbs);
            dtResultBranch.Columns.Add(dcCurrentAng);
            dtResultBranch.Columns.Add(dcTotalLoadREal);
            dtResultBranch.Columns.Add(dcSCCurrent);
            dtResultBranch.Columns.Add(CondMax1sCurrent);
            dtResultBranch.Columns.Add(dcFrom);
            dtResultBranch.Columns.Add(dcTo);
            dtResultBranch.Columns.Add(dcCondName);
            dtResultBranch.Columns.Add(dcVolt);

            ed.WriteMessage("Print Nodes\n");
            foreach (DataRow dr in dtNodes.Rows)
            {
                DataRow drNew = dtResultNode.NewRow();
                if (new Guid(dr["ConsoleGuid"].ToString()) != Guid.Empty)
                {
                    Atend.Base.Design.DPackage dPack = Atend.Base.Design.DPackage.AccessSelectByCode(new Guid(dr["ConsoleGuid"].ToString()));
                    drNew["ConsolGuid"] = dPack.Number;
                    drNew["VoltAbs"]    = Math.Round(((Complex)dr["Voltage"]).abs, 3);

                    double voltArg = ConvertToDegree(((Complex)dr["Voltage"]).arg);
                    //drNew["VoltArg"] = Math.Round(((Complex)dr["Voltage"]).arg, 2);
                    drNew["VoltArg"] = Math.Round(voltArg, 2);

                    drNew["VoltDropPer"]    = Math.Round(Convert.ToDouble(dr["VoltageDropPer"].ToString()));
                    drNew["LoadPowerReal"]  = Math.Round(((Complex)dr["LoadPower"]).real, 3);
                    drNew["LoadPowerImg"]   = Math.Round(((Complex)dr["LoadPower"]).imag, 3);
                    drNew["LoadCurrentAbs"] = Math.Round(((Complex)dr["LoadCurrent"]).abs, 3);//.ToString();
                    double loadcurrentArg = ConvertToDegree(((Complex)dr["LoadCurrent"]).arg);

                    //drNew["LoadCurrentArg"] = Math.Round(((Complex)dr["LoadCurrent"]).arg, 3);//.ToString();
                    drNew["LoadCurrentArg"] = loadcurrentArg;
                    dtResultNode.Rows.Add(drNew);
                }
            }
            ed.WriteMessage("Print Branch\n");

            Atend.Base.Calculating.CShortCircuit.AccessDelete();

            foreach (DataRow dr in dtBranch.Rows)
            {
                Atend.Base.Calculating.CShortCircuit shortCircuit = new Atend.Base.Calculating.CShortCircuit();
                if (new Guid(dr["Code"].ToString()) != Guid.Empty)
                {
                    DataRow drNew = dtResultBranch.NewRow();
                    Atend.Base.Design.DBranch branch = Atend.Base.Design.DBranch.AccessSelectByCode(new Guid(dr["Code"].ToString()));
                    //drNew["Code"] = branch.Number;

                    if ((branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.Conductor)) || (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.Jumper)) || (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.Terminal)))
                    {
                        Atend.Base.Equipment.EConductorTip ConductorTip = Atend.Base.Equipment.EConductorTip.AccessSelectByCode(branch.ProductCode);
                        Atend.Base.Equipment.EConductor    Conductor    = Atend.Base.Equipment.EConductor.AccessSelectByCode(ConductorTip.PhaseProductCode);
                        drNew["CondName"] = Conductor.Name;
                        double IbMax = Convert.ToDouble(Conductor.MaxCurrent1Second) / Math.Sqrt(_FaultDuration);
                        drNew["CondMax1sCurrent"] = Math.Round(IbMax, 1);

                        shortCircuit.CondName         = Conductor.Name;
                        shortCircuit.CondMax1SCurrent = Math.Round(IbMax, 1);
                    }

                    if (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.SelfKeeper))
                    {
                        Atend.Base.Equipment.ESelfKeeperTip SelfKeeperTip = Atend.Base.Equipment.ESelfKeeperTip.AccessSelectByCode(branch.ProductCode);
                        Atend.Base.Equipment.ESelfKeeper    SelfKeeper    = Atend.Base.Equipment.ESelfKeeper.AccessSelectByCode(SelfKeeperTip.PhaseProductCode);
                        drNew["CondName"] = SelfKeeper.Name;
                        double IbMax = Convert.ToDouble(SelfKeeper.MaxCurrent1Second) / Math.Sqrt(_FaultDuration);
                        drNew["CondMax1sCurrent"]     = Math.Round(IbMax, 1);
                        shortCircuit.CondName         = SelfKeeper.Name;
                        shortCircuit.CondMax1SCurrent = Math.Round(IbMax, 1);
                    }

                    if (branch.ProductType == Convert.ToInt32(Atend.Control.Enum.ProductType.GroundCabel))
                    {
                        Atend.Base.Equipment.EGroundCabelTip GroundTip = Atend.Base.Equipment.EGroundCabelTip.AccessSelectByCode(branch.ProductCode);
                        Atend.Base.Equipment.EGroundCabel    Ground    = Atend.Base.Equipment.EGroundCabel.AccessSelectByCode(GroundTip.PhaseProductCode);
                        drNew["CondName"] = Ground.Name;
                        double IbMax = Convert.ToDouble(Ground.MaxCurrent1Second) / Math.Sqrt(_FaultDuration);
                        drNew["CondMax1sCurrent"]     = Math.Round(IbMax, 1);
                        shortCircuit.CondName         = Ground.Name;
                        shortCircuit.CondMax1SCurrent = Math.Round(IbMax, 1);
                    }


                    drNew["Lenght"]          = dr["Length"].ToString();
                    drNew["CondUtilization"] = Math.Round(Convert.ToDouble(dr["CondUtilization"].ToString()), 3);
                    drNew["CurrentAbs"]      = Math.Round(((Complex)dr["Current"]).abs, 3);//.ToString();
                    double currentArg = ConvertToDegree(((Complex)dr["Current"]).arg);

                    //drNew["CurrentArg"] = Math.Round(((Complex)dr["Current"]).arg, 3);//.ToString();
                    drNew["CurrentArg"] = Math.Round(currentArg, 3);

                    drNew["TotalLoadReal"] = Math.Round(((Complex)dr["TotalLoad"]).arg, 3);
                    drNew["SCCurrent"]     = Math.Round(Convert.ToDouble(dr["SCCurrent"].ToString()), 0);
                    ed.WriteMessage("CondCode={0}\n", dr["CondCode"].ToString());


                    shortCircuit.Lenght          = Convert.ToDouble(dr["Length"].ToString());
                    shortCircuit.Condutilization = Math.Round(Convert.ToDouble(dr["CondUtilization"].ToString()), 3);
                    shortCircuit.CurrentAbs      = Math.Round(((Complex)dr["Current"]).abs, 3); //.ToString();

                    shortCircuit.CurrentArg = Math.Round(currentArg, 3);                        //.ToString();

                    shortCircuit.TotalLoad = Math.Round(((Complex)dr["TotalLoad"]).arg, 3);
                    shortCircuit.ScCurrent = Math.Round(Convert.ToDouble(dr["SCCurrent"].ToString()), 0);
                    ed.WriteMessage("Current={0}\n", shortCircuit.ScCurrent);


                    //از
                    DataRow[] drnodeFrom = dtNodes.Select(string.Format("ConsoleObjID={0}", dr["UpNodeId"].ToString()));
                    if (drnodeFrom.Length > 0)
                    {
                        drNew["From"]     = FindNodeComment(new Guid(drnodeFrom[0]["ConsoleGuid"].ToString()));
                        shortCircuit.From = drNew["From"].ToString();
                    }


                    //به
                    DataRow[] drnodeTo = dtNodes.Select(string.Format("ConsoleObjID={0}", dr["DnNodeId"].ToString()));
                    if (drnodeTo.Length > 0)
                    {
                        drNew["Volt"]     = Math.Round(((Complex)(drnodeTo[0]["Voltage"])).abs, 2).ToString();
                        drNew["To"]       = FindNodeComment(new Guid(drnodeTo[0]["ConsoleGuid"].ToString()));
                        shortCircuit.To   = drNew["To"].ToString();
                        shortCircuit.Volt = Math.Round(((Complex)(drnodeTo[0]["Voltage"])).abs, 2);
                    }



                    //if (new Guid(dr["Code"].ToString()) != Guid.Empty)
                    //{
                    ////Atend.Base.Equipment.EConductorTip condTip = Atend.Base.Equipment.EConductorTip.AccessSelectByCode(Convert.ToInt32(dr["CondCode"].ToString()));

                    ////Atend.Base.Equipment.EConductor conductor = Atend.Base.Equipment.EConductor.AccessSelectByCode(condTip.PhaseProductCode);
                    ////ed.WriteMessage("conductor.MaxCurrent1Second={0},SCCurrent={1}\n", conductor.MaxCurrent1Second, dr["SCCurrent"].ToString());


                    ////ed.WriteMessage("#######\n");

                    //ed.WriteMessage("&&&&&&={0}\n", dr["CondMax1sCurrent"].ToString());
                    //}
                    //else
                    //{

                    //    drNew["CondMax1sCurrent"] = dr["CondUtilizationSC"].ToString();
                    //}

                    dtResultBranch.Rows.Add(drNew);



                    if (!shortCircuit.AccessInsert())
                    {
                        ed.WriteMessage("Insert Failed\n");
                    }
                }
            }
            ////foreach (DataRow dr in dtResultBranch.Rows)
            ////{
            ////    ed.WriteMessage("dtResultBranch.CondMax1sCurrent={0}\n", dr["CondMax1sCurrent"].ToString());
            ////}

            //string code1 = "00000000-0000-0000-0000-000000000000";
            //DataRow[] drs = dtResultBranch.Select(" Code = '"+code1+"'");
            //drs[0].Delete();

            //DataRow[] drs1 = dtResultNode.Select(" ConsolGuid = '" + code1 + "'");
            //drs1[0].Delete();

            ed.WriteMessage("BindDAtA\n");
            gvBranch.AutoGenerateColumns = false;
            gvBranch.DataSource          = dtResultBranch;

            //gvNode.AutoGenerateColumns = false;
            //gvNode.DataSource = dtResultNode;
            CheckCurrent();
        }
コード例 #12
0
        private bool Validation()
        {
            //ed.WriteMessage("GoToName ValiDation\n");
            //if (Atend.Control.Common.selectedProductCode == -1)
            //{
            //    MessageBox.Show("لطفا ابتدا یک کالا را از پشتیبان انتخاب کنید", "خطا");

            //    return false;
            //}
            if (string.IsNullOrEmpty(txtName.Text))
            {
                MessageBox.Show("لطفا نام را مشخص نمایید", "خطا");
                txtName.Focus();
                return(false);
            }
            if (Atend.Base.Equipment.EGroundCabel.SearchByName(txtName.Text) == true && SelectedCabelCode == Guid.Empty)
            {
                MessageBox.Show("نام قبلا استفاده شده است", "خطا");
                txtName.Focus();
                return(false);
            }
            if (string.IsNullOrEmpty(txtCapacitance.Text))
            {
                MessageBox.Show("لطفا ظرفیت را مشخص نمایید", "خطا");
                txtCapacitance.Focus();
                return(false);
            }

            if (string.IsNullOrEmpty(txtResistance.Text))
            {
                MessageBox.Show("لطفا مقاومت اهمی را مشخص نمایید", "خطا");
                txtResistance.Focus();
                return(false);
            }

            if (string.IsNullOrEmpty(txtReactance.Text))
            {
                MessageBox.Show("لطفا مقاومت سلفی را مشخص نمایید", "خطا");
                txtReactance.Focus();
                return(false);
            }

            if (string.IsNullOrEmpty(txtMaxCurrent.Text))
            {
                MessageBox.Show("لطفا جریان را مشخص نمایید", "خطا");
                txtMaxCurrent.Focus();
                return(false);
            }

            if (string.IsNullOrEmpty(txtSize.Text))
            {
                MessageBox.Show("لطفا سایز را مشخص نمایید", "خطا");
                txtSize.Focus();
                return(false);
            }

            if (string.IsNullOrEmpty(txtMaxCurrent1Second.Text))
            {
                MessageBox.Show("لطفا حداکثر جریان در یک ثانیه را مشخص نمایید", "خطا");
                txtMaxCurrent1Second.Focus();
                return(false);
            }


            /////////////////////////////////////////////////////////////////////

            if (!Atend.Control.NumericValidation.DoubleConverter(txtCapacitance.Text))
            {
                MessageBox.Show("لطفا ظرفیت را با فرمت مناسب وارد کنید", "خطا");
                txtCapacitance.Focus();
                return(false);
            }

            if (!Atend.Control.NumericValidation.DoubleConverter(txtResistance.Text))
            {
                MessageBox.Show("لطفا مقاومت اهمی را با فرمت مناسب وارد کنید", "خطا");
                txtResistance.Focus();
                return(false);
            }

            if (!Atend.Control.NumericValidation.DoubleConverter(txtReactance.Text))
            {
                MessageBox.Show("لطفا مقاومت سلفی را با فرمت مناسب وارد کنید", "خطا");
                txtReactance.Focus();
                return(false);
            }

            if (!Atend.Control.NumericValidation.DoubleConverter(txtMaxCurrent.Text))
            {
                MessageBox.Show("لطفا جریان را با فرمت مناسب وارد کنید", "خطا");
                txtMaxCurrent.Focus();
                return(false);
            }

            if (!Atend.Control.NumericValidation.Int32Converter(txtSize.Text))
            {
                MessageBox.Show("لطفا سایز را با فرمت مناسب وارد کنید", "خطا");
                txtSize.Focus();
                return(false);
            }

            if (!Atend.Control.NumericValidation.Int32Converter(txtMaxCurrent1Second.Text))
            {
                MessageBox.Show("لطفا حداکثر جریان در یک ثانیه را با فرمت مناسب وارد کنید", "خطا");
                txtMaxCurrent1Second.Focus();
                return(false);
            }

            //ed.WriteMessage("GoToVol ValiDation\n");

            if (string.IsNullOrEmpty(cboVol.Text))
            {
                MessageBox.Show("لطفا ولتاژ را مشخص نمایید", "خطا", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.RtlReading);
                cboVol.Focus();
                return(false);
            }
            //ed.WriteMessage("GoToVol ValiDation\n");


            if (!Atend.Control.NumericValidation.DoubleConverter(cboVol.Text))
            {
                MessageBox.Show("لطفاً ولتاژ را با فرمت مناسب وارد نمایید", "خطا", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.RtlReading);
                cboVol.Focus();
                //txtVol.Select(0, txtVol.Text.Length);
                return(false);
            }

            //ed.WriteMessage("GoToCrossSection ValiDation\n");



            if (string.IsNullOrEmpty(txtCrossSectionArea.Text))
            {
                MessageBox.Show("لطفا سطح مقطع را مشخص نمایید", "خطا", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.RtlReading);
                txtCrossSectionArea.Focus();

                return(false);
            }

            //ed.WriteMessage("IGoToNumString ValiDation\n");


            if (string.IsNullOrEmpty(nudNumString.Text))
            {
                MessageBox.Show("لطفا تعداد رشته را مشخص نمایید", "خطا", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.RtlReading);
                nudNumString.Focus();
                return(false);
            }
            //ed.WriteMessage("GoToType ValiDation\n");



            if (string.IsNullOrEmpty(cboType.Text))
            {
                MessageBox.Show("لطفا نوع را مشخص نمایید", "خطا", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.RtlReading);
                cboType.Focus();
                return(false);
            }

            Atend.Base.Equipment.EGroundCabel groundcabel = Atend.Base.Equipment.EGroundCabel.CheckForExist(Convert.ToInt32(nudNumString.Value), Convert.ToDouble(txtCrossSectionArea.Text), Convert.ToInt16(cboType.SelectedValue.ToString()),
                                                                                                            double.Parse(cboVol.Text), Convert.ToInt32(txtSize.Text), Convert.ToDouble(txtResistance.Text), Convert.ToDouble(txtReactance.Text),
                                                                                                            Convert.ToDouble(txtMaxCurrent.Text), Convert.ToDouble(txtCapacitance.Text));
            if (groundcabel.Code != -1 && SelectedCabelCode == Guid.Empty)
            {
                if (MessageBox.Show("کابل زمینی با مشخصات داده شده موجود میباشد\n\n کابل زمینی با مشخصات فوق  : " + groundcabel.Name + "\n\n" + "آیا مایل به ادامه  ثبت می باشید؟", "خطا", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
                {
                    nudNumString.Focus();
                    return(false);
                }
            }

            if (!Atend.Global.Utility.UBinding.CheckGridValidation(gvOperation, 3))
            {
                MessageBox.Show("لطفا تعداد آماده سازی را با فرمت مناسب وارد نمایید", "خطا");
                gvOperation.Focus();
                return(false);
            }
            if (!Atend.Global.Utility.UBinding.CheckGridValidation(gvSelectedEquipment, 2))
            {
                MessageBox.Show("لطفا تعداد تجهیزات جانبی را با فرمت مناسب وارد نمایید", "خطا");
                gvSelectedEquipment.Focus();
                return(false);
            }

            for (int j = 0; j < gvSelectedEquipment.Rows.Count; j++)
            {
                Atend.Base.Equipment.EProductPackage _EProductPackage = new Atend.Base.Equipment.EProductPackage();
                _EProductPackage.XCode     = new Guid(gvSelectedEquipment.Rows[j].Cells[0].Value.ToString());
                _EProductPackage.Count     = Convert.ToInt32(gvSelectedEquipment.Rows[j].Cells[2].Value.ToString());
                _EProductPackage.TableType = Convert.ToInt16(gvSelectedEquipment.Rows[j].Cells[3].Value.ToString());

                if (Atend.Base.Equipment.EContainerPackage.FindLoopNode(SelectedCabelCode, Convert.ToInt32(Atend.Control.Enum.ProductType.GroundCabel), _EProductPackage.XCode, _EProductPackage.TableType))
                {
                    MessageBox.Show(string.Format("تجهیز '{0}' در زیر تجهیزات موجود می باشد", txtName.Text), "خطا");
                    gvSelectedEquipment.Focus();
                    return(false);
                }
            }

            return(CheckStatuseOfAccessChangeDefault());
            //return true;
        }
コード例 #13
0
        private void Save()
        {
            txtName.Focus();
            //ed.WriteMessage("I aM In sve Method");
            Atend.Base.Equipment.EGroundCabel middleGroundCabel = new Atend.Base.Equipment.EGroundCabel();
            ArrayList EOperation = new ArrayList();

            middleGroundCabel.ProductCode = Atend.Control.Common.selectedProductCode;
            middleGroundCabel.Vol         = double.Parse(cboVol.Text);
            middleGroundCabel.Type        = Convert.ToInt16(cboType.SelectedValue.ToString());;
            middleGroundCabel.Code        = Code;
            //if (nudNumString.SelectedIndex == 0 | nudNumString.SelectedIndex == 1 | cboNumString.SelectedIndex == 2 | cboNumString.SelectedIndex == 3 | cboNumString.SelectedIndex == 4)
            //{
            //    middleGroundCabel.NumString = Convert.ToInt32(cboNumString.Text);
            //}
            //else
            //{
            //    middleGroundCabel.NumString = 6;
            //}
            middleGroundCabel.NumString = Convert.ToInt32(nudNumString.Value);
            middleGroundCabel.Name      = txtName.Text;
            //if (cboNumString.SelectedIndex == 0 | cboNumString.SelectedIndex == 1 | cboNumString.SelectedIndex == 2 | cboNumString.SelectedIndex == 3 | cboNumString.SelectedIndex == 4)
            //{
            //    middleGroundCabel.CrossSectionArea =Convert.ToDouble(cboCrossSectionArea.Text);
            //}
            //else
            //{
            //    middleGroundCabel.CrossSectionArea = Convert.ToDouble(CrossSectionValue1[cboCrossSectionArea.SelectedIndex]);
            //}
            middleGroundCabel.CrossSectionArea  = Convert.ToDouble(txtCrossSectionArea.Text);
            middleGroundCabel.Comment           = txtComment.Text;
            middleGroundCabel.IsDefault         = IsDefault;
            middleGroundCabel.MaxCurrent        = Convert.ToDouble(txtMaxCurrent.Text);
            middleGroundCabel.Reactance         = Convert.ToDouble(txtReactance.Text);
            middleGroundCabel.Resistance        = Convert.ToDouble(txtResistance.Text);
            middleGroundCabel.Capacitance       = Convert.ToDouble(txtCapacitance.Text);
            middleGroundCabel.Size              = Convert.ToInt32(txtSize.Text);
            middleGroundCabel.MaxCurrent1Second = Convert.ToDouble(txtMaxCurrent1Second.Text);
            //saveOperation
            //ed.WriteMessage("I aM In sve Opearation");

            //Equipment
            ArrayList EPackageProduct = new ArrayList();

            for (int j = 0; j < gvSelectedEquipment.Rows.Count; j++)
            {
                Atend.Base.Equipment.EProductPackage _EProductPackage = new Atend.Base.Equipment.EProductPackage();
                _EProductPackage.XCode     = new Guid(gvSelectedEquipment.Rows[j].Cells[0].Value.ToString());
                _EProductPackage.Count     = Convert.ToInt32(gvSelectedEquipment.Rows[j].Cells[2].Value.ToString());
                _EProductPackage.TableType = Convert.ToInt16(gvSelectedEquipment.Rows[j].Cells[3].Value.ToString());
                EPackageProduct.Add(_EProductPackage);
            }
            middleGroundCabel.EquipmentList = EPackageProduct;

            //Operation
            for (int i = 0; i < gvOperation.Rows.Count; i++)
            {
                Atend.Base.Equipment.EOperation _EOperation = new Atend.Base.Equipment.EOperation();
                _EOperation.ProductID = Convert.ToInt32(gvOperation.Rows[i].Cells[0].Value);
                _EOperation.Count     = Convert.ToDouble(gvOperation.Rows[i].Cells[3].Value);
                EOperation.Add(_EOperation);
            }
            middleGroundCabel.OperationList = EOperation;

            if (SelectedCabelCode == Guid.Empty)
            {
                if (middleGroundCabel.InsertX())
                {
                    Reset();
                }
                else
                {
                    MessageBox.Show("امکان ثبت کردن اطلاعات نمی باشد", "خطا");
                }
            }
            else
            {
                middleGroundCabel.XCode = SelectedCabelCode;
                //MessageBox.Show("go to update method : " + Pole.Code + "\n");
                if (middleGroundCabel.UpdateX())
                {
                    Reset();
                }
                else
                {
                    MessageBox.Show("امکان به روز رسانی اطلاعات نمی باشد", "خطا");
                }
            }
        }