/ - Diff - HYTOS - 일정관리

개정판 154d8f43

ID	154d8f43aebc83a10debd29d4dde8deae0f977ed
상위	3d7ff99c
하위	b7a29053

gaqhf 이(가) 5년 이상 전에 추가함

dev issue #498 : OPC 연결 기본 로직 완료

Change-Id: I0150a1f6234dafa298e7bf2a405d290f84ad93a5

DTI_PID/SPPIDConverter/AutoModeling.cs
105	105	RunSpecBreakModeling();
106	106	// Join SameConnector
107	107	RunJoinRunForSameConnector();
108		// Check FlowDirection
109		RunFlowDirection();
110	108	// Join Run
111	109	RunJoinRun();
	110	// Check FlowDirection
	111	RunFlowDirection();
112	112	//Line Number Modeling
113	113	RunLineNumberModeling();
114	114	// Note Modeling
...	...
140	140	}
141	141	finally
142	142	{
143		Project_DB.InsertDrawingInfo(document.PATH, drawingNumber, drawingName, document);
	143	Project_DB.InsertDrawingInfoAndOPCInfo(document.PATH, drawingNumber, drawingName, document);
144	144	if (SplashScreenManager.Default != null && SplashScreenManager.Default.IsSplashFormVisible)
145	145	{
146	146	SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.ClearParent, null);
...	...
515	515	SetFlowDirectionByLine(line.SPPID.ModelItemId);
516	516
517	517	ReleaseCOMObjects(modelItem);
	518	modelItem = null;
518	519	}
519	520	}
520	521
...	...
533	534	SetFlowDirectionByLine(modelId);
534	535
535	536	ReleaseCOMObjects(zeroLengthModelItem);
	537	zeroLengthModelItem = null;
	538
536	539	SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.UpProgress, null);
537	540	}
538	541	foreach (var modelId in ZeroLengthModelItemIDReverse)
...	...
548	551	SetFlowDirectionByLine(modelId);
549	552
550	553	ReleaseCOMObjects(zeroLengthModelItem);
	554	zeroLengthModelItem = null;
	555
551	556	SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.UpProgress, null);
552	557	}
553	558	foreach (var modelId in ZeroLengthSymbolToSymbolModelItemID)
...	...
581	586	}
582	587	}
583	588	ReleaseCOMObjects(modelItem);
	589	modelItem = null;
584	590	}
585	591
586	592	void SetSymbolFlowDirectionByRelationShip(LMRelationship relationship, LMConnector connector, string sFlowDirection)
...	...
597	603
598	604	symbolModelItem.Commit();
599	605	ReleaseCOMObjects(symbolModelItem);
	606	symbolModelItem = null;
600	607	}
601	608	// Item1이 Symbol
602	609	else if (!DBNull.Value.Equals(relationship.Item2RepresentationID) && relationship.Item2RepresentationID == connector.Id &&
...	...
610	617
611	618	symbolModelItem.Commit();
612	619	ReleaseCOMObjects(symbolModelItem);
	620	symbolModelItem = null;
613	621	}
614	622	}
615	623
...	...
2800	2808	List<string> result = new List<string>();
2801	2809	modelItemIDs = modelItemIDs.Distinct().ToList();
2802	2810	string originalName = GetSPPIDFileName(modelId);
	2811	bool existZeroLength = false;
2803	2812	foreach (var item in modelItemIDs)
2804	2813	{
2805	2814	string fileName = GetSPPIDFileName(item);
...	...
2808	2817	else
2809	2818	{
2810	2819	LMConnector connector = GetLMConnectorOnlyOne(item);
2811		if (connector != null && Convert.ToBoolean(connector.get_IsZeroLength()))
	2820	if (connector != null && Convert.ToBoolean(connector.get_IsZeroLength()) && connector.LabelPersists.Count == 0)
2812	2821	{
2813	2822	result.Add(item);
2814	2823	ReleaseCOMObjects(connector);
	2824	existZeroLength = true;
2815	2825	}
2816	2826	}
2817	2827	}
	2828
	2829	if (result.Count == 1 && existZeroLength)
	2830	{
	2831	LMConnector connector = GetLMConnectorOnlyOne(result[0]);
	2832	LMConnector newConnector = ReModelingLMConnector(connector, originalName);
	2833	result.Clear();
	2834	if (newConnector != null)
	2835	result.Add(newConnector.ModelItemID);
	2836
	2837	ReleaseCOMObjects(connector);
	2838	connector = null;
	2839	ReleaseCOMObjects(newConnector);
	2840	newConnector = null;
	2841	}
2818	2842
2819	2843	return result;
2820	2844	}

             private string _SIZE;
             private double _SIZE_WIDTH;
             private double _SIZE_HEIGHT;
             private string _UID;
             private List<Symbol> _SYMBOLS = new List<Symbol>();
             private List<Text> _TEXTINFOS = new List<Text>();
             private List<Note> _NOTES = new List<Note>();
-...
             public bool Enable { get => _Enable; set => _Enable = value; }
             public bool Validation { get => _Validation; set => _Validation = value; }
             public bool MappingValidation { get => _MappingValidation; set => _MappingValidation = value; }
             public string UID { get => _UID; set => _UID = value; }
             StringBuilder validationStringBuilder = new StringBuilder();

     using Newtonsoft.Json;
     using System.Runtime.InteropServices;
     using System.Reflection;
     using Converter.SPPID.OPC;
     namespace Converter.SPPID.Wrapper
+    {
-...
+                {
                     textEditDrawingX.EditValue = Settings.Default.DrawingX;
                     textEditDrawingY.EditValue = Settings.Default.DrawingY;
                     Project_Info _ProjectInfo = Project_Info.GetInstance();
                     _ProjectInfo.DefaultPath = Settings.Default.LatestProjectPath;
+                }
                 catch (Exception ex)
+                {
-...
             private void btnLinkOPC_Click(object sender, EventArgs e)
+            {
                 if (application.ActiveDocument == null)
                     application.Documents.Add();
                 DataTable tOPCInfo = Project_DB.SelectOPCInfo();
                 DataTable tOPCRelations = Project_DB.SelectOPCRelations();
                 DataTable tDrawingInfo = Project_DB.SelectDrawingInfo();
                 dynamic dApplication = Interaction.GetObject("", "PIDAutomation.Application");
                 foreach (DataRow row in tOPCInfo.Rows)
+                {
                     if (!Convert.ToBoolean(row["PAIRED"]))
+                    {
                         string drawingUID = row["ID2_DRAWING_UID"].ToString();
                         string OPCUID = row["ID2_OPC_UID"].ToString();
                         DataRow[] rows = tOPCRelations.Select(string.Format("(From_Drawings_UID = '{0}' AND From_OPC_UID = '{1}') OR (To_Drawings_UID = '{0}' AND To_OPC_UID = '{1}')", drawingUID, OPCUID));
                         if (rows.Length == 2)
+                        {
                             string fromDrawingsUID1 = rows[0]["From_Drawings_UID"].ToString();
                             string fromDrawingsUID2 = rows[1]["From_Drawings_UID"].ToString();
                             string fromOPCUID1 = rows[0]["From_OPC_UID"].ToString();
                             string fromOPCUID2 = rows[1]["From_OPC_UID"].ToString();
                             string toDrawingsUID1 = rows[0]["To_Drawings_UID"].ToString();
                             string toDrawingsUID2 = rows[1]["To_Drawings_UID"].ToString();
                             string toOPCUID1 = rows[0]["To_OPC_UID"].ToString();
                             string toOPCUID2 = rows[1]["To_OPC_UID"].ToString();
                             DataRow[] fromDrawing = tDrawingInfo.Select(string.Format("ID2_DRAWING_UID = '{0}'", fromDrawingsUID1));
                             DataRow[] toDrawing = tDrawingInfo.Select(string.Format("ID2_DRAWING_UID = '{0}'", toDrawingsUID1));
                             if (fromOPCUID1 == toOPCUID2 && fromOPCUID2 == toOPCUID1 && fromDrawing.Length == 1 && toDrawing.Length == 1)
+                            {
                                 DataRow fromOPCInfoRow = tOPCInfo.Select(string.Format("ID2_OPC_UID = '{0}'", fromOPCUID1))[0];
                                 DataRow toOPCInfoRow = tOPCInfo.Select(string.Format("ID2_OPC_UID = '{0}'", toOPCUID1))[0];
                                 string fromOPCModelId = fromOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString();
                                 string toOPCModelId = toOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString();
                                 string toDrawingName = toDrawing[0]["DRAWINGNAME"].ToString();
                                 AutoModeling_OPC opc = new AutoModeling_OPC(dApplication, application, fromOPCModelId, toOPCModelId, toDrawingName);
                                 if (opc.Run())
+                                {
                                     fromOPCInfoRow["PAIRED"] = true;
                                     toOPCInfoRow["PAIRED"] = true;
                                     Project_DB.InsertOPCInfo(fromOPCInfoRow["ID2_OPC_UID"].ToString(), fromOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString(), fromOPCInfoRow["ID2_DRAWING_UID"].ToString(), true);
                                     Project_DB.InsertOPCInfo(toOPCInfoRow["ID2_OPC_UID"].ToString(), toOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString(), toOPCInfoRow["ID2_DRAWING_UID"].ToString(), true);
+                                }
                                 break;
+                            }
+                        }
+                    }
+                }
                 tOPCInfo.Dispose();
                 tOPCRelations.Dispose();
                 tDrawingInfo.Dispose();
                 ReleaseCOMObjects(dApplication);
                 dApplication = null;
                 //dynamic application = Interaction.GetObject("", "PIDAutomation.Application");
                 //WrapperApplication wApp = new WrapperApplication(application.Application);
                 //Ingr.RAD2D.Application radApp = wApp.RADApplication;
-...
             #region TEST
             private void simpleButton1_Click(object sender, EventArgs e)
+            {
                 return;
                 Thread outThread = new Thread(func2 =>
+                {
                     for (int i = 100; i < 120; i++)

                     MessageBox.Show(Msg.SelectDocument, Msg.Warning, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                     return;
+                }
                 DataTable tDrawing = Project_DB.SelectDrawings();
                 this._Documents.Clear();
                 foreach (int rowHandle in gridViewConverter.GetSelectedRows())
+                {
-...
                     string _Template = gridViewConverter.GetRowCellDisplayText(rowHandle, "colTemplate");
                     string _DrawingNumber = gridViewConverter.GetRowCellDisplayText(rowHandle, "colDrawingNumber");
                     string _DrawingName = gridViewConverter.GetRowCellDisplayText(rowHandle, "colDrawingName");
                     DataRow[] rows = tDrawing.Select(string.Format("NAME = '{0}'", Path.GetFileNameWithoutExtension(_FilePath) + ".png"));
                     if (rows.Length != 1)
                         continue;
                     SPPID_Document document = _DicDocuments[_FilePath];
                     document.Unit = _Unit;
                     document.Template = _Template;
                     document.DrawingNumber = _DrawingNumber;
                     document.DrawingName = _DrawingName;
                     document.UID = rows[0]["UID"].ToString();
                     document.SymbolTable = _ID2SymbolTable;
                     document.SymbolMappings = symbolMappings;
-...
                         this._Documents.Add(document);
+                }
                 if (_Documents.Count > 50)
                     checkEditCloseDocument.Checked = true;
                 tDrawing.Dispose();
                 DialogResult = DialogResult.OK;
+            }

             const string SPPID_SETTING_TABLE = "T_SPPID_SETTING_TABLE";
             const string SPPID_LABEL_INFO_TABLE = "T_SPPID_LABEL_INFO";
             const string SPPID_DRAWING_INFO = "T_SPPID_DRAWING_INFO";
             const string SPPID_OPC_INFO = "T_SPPID_OPC_INFO";
             const string LineProperties_TABLE = "LineProperties";
             const string LineTypes_TABLE = "LineTypes";
             const string SymbolType_TABLE = "SymbolType";
             const string SymbolAttribute_TABLE = "SymbolAttribute";
             const string Symbol_TABLE = "Symbol";
             const string OPCRelations_TABLE = "OPCRelations";
             public static bool ConnTestAndCreateTable()
+            {
-...
+                        }
                         if (dt.Select(string.Format("NAME = '{0}'", SPPID_DRAWING_INFO)).Length == 0)
+                        {
                             cmd.CommandText = string.Format("CREATE TABLE {0} (PATH TEXT PRIMARY KEY, DRAWINGNUMBER TEXT, DRAWINGNAME TEXT, DOCUMENT Text)", SPPID_DRAWING_INFO);
                             cmd.CommandText = string.Format("CREATE TABLE {0} (ID2_DRAWING_UID Text PRIMARY KEY, PATH TEXT, DRAWINGNUMBER TEXT, DRAWINGNAME TEXT)", SPPID_DRAWING_INFO);
                             cmd.ExecuteNonQuery();
+                        }
                         if (dt.Select(string.Format("NAME = '{0}'", SPPID_OPC_INFO)).Length == 0)
+                        {
                             cmd.CommandText = string.Format("CREATE TABLE {0} (ID2_OPC_UID TEXT PRIMARY KEY, SPPID_OPC_MODELITEM_ID TEXT, ID2_DRAWING_UID, PAIRED BOOL)", SPPID_OPC_INFO);
                             cmd.ExecuteNonQuery();
+                        }
+                    }
-...
                     using (DataTable dt = new DataTable())
+                    {
                         dt.Load(dr);
                         if (!dt.Columns.Contains("DOCUMENT"))
                         if (dt.Columns.Contains("DOCUMENT"))
+                        {
                             cmd.CommandText = string.Format("ALTER TABLE {0} ADD COLUMN DOCUMENT Text", SPPID_DRAWING_INFO);
                             cmd.CommandText = string.Format("DROP TABLE {0}", SPPID_DRAWING_INFO);
                             cmd.ExecuteNonQuery();
                             cmd.CommandText = string.Format("CREATE TABLE {0} (ID2_DRAWING_UID Text PRIMARY KEY, PATH TEXT, DRAWINGNUMBER TEXT, DRAWINGNAME TEXT)", SPPID_DRAWING_INFO);
                             cmd.ExecuteNonQuery();
+                        }
+                    }
-...
                 return dt;
+            }
             public static DataTable SelectOPCRelations()
+            {
                 DataTable dt = new DataTable();
                 Project_Info projectInfo = Project_Info.GetInstance();
                 using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))
+                {
                     try
+                    {
                         connection.Open();
                         using (SQLiteCommand cmd = connection.CreateCommand())
+                        {
                             cmd.CommandText = string.Format("SELECT * FROM {0}", OPCRelations_TABLE);
                             using (SQLiteDataReader dr = cmd.ExecuteReader())
                                 dt.Load(dr);
+                        }
                         connection.Close();
+                    }
                     catch (Exception ex)
+                    {
+                    }
                     finally
+                    {
                         connection.Dispose();
+                    }
+                }
                 return dt;
+            }
             public static DataTable SelectDrawings()
+            {
                 DataTable dt = new DataTable();
                 Project_Info projectInfo = Project_Info.GetInstance();
                 using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))
+                {
                     try
+                    {
                         connection.Open();
                         using (SQLiteCommand cmd = connection.CreateCommand())
+                        {
                             cmd.CommandText = string.Format("SELECT * FROM {0}", "Drawings");
                             using (SQLiteDataReader dr = cmd.ExecuteReader())
                                 dt.Load(dr);
+                        }
                         connection.Close();
+                    }
                     catch (Exception ex)
+                    {
+                    }
                     finally
+                    {
                         connection.Dispose();
+                    }
+                }
                 return dt;
+            }
             public static DataTable SelectOPCInfo()
+            {
                 DataTable dt = new DataTable();
                 Project_Info projectInfo = Project_Info.GetInstance();
                 using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))
+                {
                     try
+                    {
                         connection.Open();
                         using (SQLiteCommand cmd = connection.CreateCommand())
+                        {
                             cmd.CommandText = string.Format("SELECT * FROM {0} WHERE SPPID_OPC_MODELITEM_ID IS NOT NULL AND PAIRED = False", SPPID_OPC_INFO);
                             using (SQLiteDataReader dr = cmd.ExecuteReader())
                                 dt.Load(dr);
+                        }
                         connection.Close();
+                    }
                     catch (Exception ex)
+                    {
+                    }
                     finally
+                    {
                         connection.Dispose();
+                    }
+                }
                 return dt;
+            }
             public static DataTable SelectDrawingInfo()
+            {
                 DataTable dt = new DataTable() { Locale = CultureInfo.CurrentCulture };
                 DataTable dt = new DataTable();
                 Project_Info projectInfo = Project_Info.GetInstance();
                 using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))
+                {
-...
                         connection.Open();
                         using (SQLiteCommand cmd = connection.CreateCommand())
+                        {
                             cmd.CommandText = string.Format("SELECT * FROM {0}",SPPID_DRAWING_INFO);
                             //using (SQLiteDataAdapter da = new SQLiteDataAdapter(cmd))
                             //    da.Fill(dt);
                             cmd.CommandText = string.Format("SELECT * FROM {0}", SPPID_DRAWING_INFO);
                             using (SQLiteDataReader dr = cmd.ExecuteReader())
+                            {
                                 dt.Columns.Add("PATH", typeof(string));
                                 dt.Columns.Add("DRAWINGNUMBER", typeof(string));
                                 dt.Columns.Add("DRAWINGNAME", typeof(string));
                                 dt.Columns.Add("DOCUMENT", typeof(SPPID.Model.SPPID_Document));
                                 while (dr.Read())
+                                {
                                     DataRow row = dt.NewRow();
                                     row["PATH"] = dr["PATH"];
                                     row["DRAWINGNUMBER"] = dr["DRAWINGNUMBER"];
                                     row["DRAWINGNAME"] = dr["DRAWINGNAME"];
                                     string jsonString = (string)dr["DOCUMENT"];
                                     JsonSerializerSettings settings = new JsonSerializerSettings
+                                    {
                                         NullValueHandling = NullValueHandling.Ignore,
                                         ObjectCreationHandling = ObjectCreationHandling.Replace
                                     };
                                     SPPID.Model.SPPID_Document doc = JsonConvert.DeserializeObject<SPPID.Model.SPPID_Document>(jsonString, settings);
                                     row["DOCUMENT"] = doc;
                                     dt.Rows.Add(row);
+                                }
                                 //dt.Load(dr, LoadOption.Upsert);
+                            }
                                 dt.Load(dr);
+                        }
                         connection.Close();
+                    }
-...
                 return true;
+            }
             public static bool InsertDrawingInfo(string path, string drawingNumber, string drawingName, SPPID.Model.SPPID_Document document)
             public static bool InsertDrawingInfoAndOPCInfo(string path, string drawingNumber, string drawingName, SPPID.Model.SPPID_Document document)
+            {
                 Project_Info projectInfo = Project_Info.GetInstance();
                 using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))
-...
+                            {
                                 using (SQLiteCommand cmd = connection.CreateCommand())
+                                {
                                     cmd.CommandText = string.Format("INSERT OR REPLACE INTO {0} (PATH, DRAWINGNUMBER, DRAWINGNAME, DOCUMENT) VALUES (@PATH, @DRAWINGNUMBER, @DRAWINGNAME, @DOCUMENT)", SPPID_DRAWING_INFO);
                                     cmd.CommandText = string.Format("INSERT OR REPLACE INTO {0} (ID2_DRAWING_UID, PATH, DRAWINGNUMBER, DRAWINGNAME) VALUES (@ID2_DRAWING_UID, @PATH, @DRAWINGNUMBER, @DRAWINGNAME)", SPPID_DRAWING_INFO);
                                     cmd.Parameters.AddWithValue("@ID2_DRAWING_UID", document.UID);
                                     cmd.Parameters.AddWithValue("@PATH", path);
                                     cmd.Parameters.AddWithValue("@DRAWINGNUMBER", drawingNumber);
                                     cmd.Parameters.AddWithValue("@DRAWINGNAME", drawingName);
                                     cmd.Parameters.AddWithValue("@DOCUMENT", JsonConvert.SerializeObject(document));
                                     cmd.ExecuteNonQuery();
+                                }
                                 List<Symbol> OPCs = document.SYMBOLS.FindAll(x => x.TYPE == "Piping OPC's" || x.TYPE == "Instrument OPC's");
                                 foreach (var item in OPCs)
+                                {
                                     using (SQLiteCommand cmd = connection.CreateCommand())
+                                    {
                                         cmd.CommandText = string.Format("INSERT OR REPLACE INTO {0} (ID2_OPC_UID, SPPID_OPC_MODELITEM_ID, ID2_DRAWING_UID, PAIRED) VALUES (@ID2_OPC_UID, @SPPID_OPC_MODELITEM_ID, @ID2_DRAWING_UID, @PAIRED)", SPPID_OPC_INFO);
                                         cmd.Parameters.AddWithValue("@ID2_OPC_UID", item.UID);
                                         cmd.Parameters.AddWithValue("@SPPID_OPC_MODELITEM_ID", item.SPPID.ModelItemID);
                                         cmd.Parameters.AddWithValue("@ID2_DRAWING_UID", document.UID);
                                         cmd.Parameters.AddWithValue("@PAIRED", false);
                                         cmd.ExecuteNonQuery();
+                                    }
+                                }
                                 transaction.Commit();
                                 connection.Close();
+                            }
                             catch (Exception ex)
+                            {
                                 transaction.Rollback();
+                            }
                             finally
+                            {
                                 transaction.Dispose();
+                            }
+                        }
+                    }
                     catch (Exception ex)
+                    {
                         return false;
+                    }
                     finally
+                    {
                         connection.Dispose();
+                    }
+                }
                 return true;
+            }
             public static bool InsertOPCInfo(string UID, string ModelItemID, string drawingUID, bool Paired)
+            {
                 Project_Info projectInfo = Project_Info.GetInstance();
                 using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))
+                {
                     try
+                    {
                         connection.Open();
                         using (SQLiteTransaction transaction = connection.BeginTransaction())
+                        {
                             try
+                            {
                                 using (SQLiteCommand cmd = connection.CreateCommand())
+                                {
                                     cmd.CommandText = string.Format("INSERT OR REPLACE INTO {0} (ID2_OPC_UID, SPPID_OPC_MODELITEM_ID, ID2_DRAWING_UID, PAIRED) VALUES (@ID2_OPC_UID, @SPPID_OPC_MODELITEM_ID, @ID2_DRAWING_UID, @PAIRED)", SPPID_OPC_INFO);
                                     cmd.Parameters.AddWithValue("@ID2_OPC_UID", UID);
                                     cmd.Parameters.AddWithValue("@SPPID_OPC_MODELITEM_ID", ModelItemID);
                                     cmd.Parameters.AddWithValue("@ID2_DRAWING_UID", drawingUID);
                                     cmd.Parameters.AddWithValue("@PAIRED", Paired);
                                     cmd.ExecuteNonQuery();
+                                }
                                 transaction.Commit();
                                 connection.Close();
+                            }

+    {
         public class AutoModeling_OPC
+        {
             Placement _placement;
             LMADataSource dataSource;
             dynamic application;
             dynamic drawing;
             Ingr.RAD2D.Application radApp;
             List<SPPID_Document> allDocuments;
             string fromOPCModelId;
             string toOPCModelId;
             string toDrawingName;
             public AutoModeling_OPC(List<SPPID_Document> allDocuments, dynamic application, Ingr.RAD2D.Application radApp)
             public AutoModeling_OPC(dynamic application, Ingr.RAD2D.Application radApp, string fromOPCModelId, string toOPCModelId, string toDrawingName)
+            {
                 this.application = application;
                 this.radApp = radApp;
                 this.allDocuments = allDocuments;
                 this.fromOPCModelId = fromOPCModelId;
                 this.toOPCModelId = toOPCModelId;
                 this.toDrawingName = toDrawingName;
+            }
             public void Run()
             public bool Run()
+            {
                 _placement = new Placement();
                 dataSource = _placement.PIDDataSource;
                 foreach (var document in allDocuments)
+                {
                     foreach (var opc in document.SYMBOLS)
+                    {
                         if ((opc.TYPE == "Piping OPC's" ||
                             opc.TYPE == "Instrument OPC's") &&
                             !string.IsNullOrEmpty(opc.SPPID.ModelItemID))
+                        {
                             PairedOPCModeling(opc);
+                        }
+                    }
+                }
                 bool result = false;
                 if (OpenDrawing(toDrawingName))
                     result = PairedOPCModeling();
                 CloseDrawing();
                 ReleaseCOMObjects(_placement);
                 ReleaseCOMObjects(dataSource);
                 return result;
+            }
             public void PairedOPCModeling(Symbol opc)
             public bool PairedOPCModeling()
+            {
                 bool result = false;
                 LMOPC _LMOPC = dataSource.GetOPC(opc.SPPID.ModelItemID);
                 LMOPC pairOPC = _LMOPC.pairedWithOPCObject;
                 foreach (LMRepresentation rep in pairOPC.Representations)
                     if (rep.DrawingID != "0")
                         result = true;
                 Placement _placement = new Placement();
                 LMADataSource dataSource = _placement.PIDDataSource;
                 if (!result)
                 bool result = false;
                 bool isPaired = false;
                 LMOPC _FROM_OPC = dataSource.GetOPC(fromOPCModelId);
                 LMOPC _TO_OPC = dataSource.GetOPC(toOPCModelId);
                 if (_FROM_OPC != null && _FROM_OPC.get_ItemStatus() == "Active" && _TO_OPC != null && _TO_OPC.get_ItemStatus() == "Active")
+                {
                     // OPC Pair 찾아서 도면 오픈후 Pair 모델링
                     BaseModel.Attribute pathAttribute = opc.ATTRIBUTES.Find(x => x.ATTRIBUTE == "PATH");
                     BaseModel.Attribute linkOPCAttribute = opc.ATTRIBUTES.Find(x => x.ATTRIBUTE == "LinkOPC");
                     string symbolPath = GetSPPIDFileName(_FROM_OPC);
                     LMOPC pairOPC = _FROM_OPC.pairedWithOPCObject;
                     SPPID_Document targetDocument = allDocuments.Find(x => x.PATH == pathAttribute.VALUE);
                     if (targetDocument != null)
                     foreach (LMRepresentation rep in pairOPC.Representations)
                         if (rep.DrawingID != "0")
                             isPaired = true;
                     try
+                    {
                         Symbol targetOPC = SPPIDUtil.FindObjectByUID(targetDocument, linkOPCAttribute.VALUE) as Symbol;
                         if (targetOPC != null && OpenDrawing(targetDocument.SPPID_DrawingName))
                         if (!isPaired)
+                        {
                             LMSymbol targetLMOPC = dataSource.GetSymbol(targetOPC.SPPID.RepresentationId);
                             if (targetLMOPC != null)
                             foreach (LMRepresentation rep in _TO_OPC.Representations)
+                            {
                                 int mirror = targetLMOPC.get_IsMirroredIndex();
                                 double angle = Convert.ToDouble(targetLMOPC.get_RotationAngle());
                                 double x = targetLMOPC.get_XCoordinate();
                                 double y = targetLMOPC.get_YCoordinate();
                                 LMSymbol newOPC = null;
                                 foreach (LMConnector LMConnector in targetLMOPC.Avoid1Connectors)
                                 LMSymbol removeSymbol = dataSource.GetSymbol(rep.Id);
                                 if (removeSymbol != null)
+                                {
                                     _placement.PIDRemovePlacement(targetLMOPC.AsLMRepresentation());
                                     ReleaseCOMObjects(targetLMOPC);
                                     newOPC = _placement.PIDPlaceSymbol(targetOPC.SPPID.MAPPINGNAME, x, y, Mirror: mirror, Rotation: angle, ExistingItem: pairOPC.AsLMAItem(), TargetItem: LMConnector);
                                     break;
+                                }
                                     ZoomObjectByGraphicOID(removeSymbol.get_GraphicOID().ToString());
                                 if (newOPC == null)
+                                {
                                     foreach (LMConnector LMConnector in targetLMOPC.Avoid2Connectors)
                                     int mirror = removeSymbol.get_IsMirroredIndex();
                                     double angle = Convert.ToDouble(removeSymbol.get_RotationAngle());
                                     double x = removeSymbol.get_XCoordinate();
                                     double y = removeSymbol.get_YCoordinate();
                                     LMSymbol newOPC = null;
                                     foreach (LMConnector LMConnector in removeSymbol.Avoid1Connectors)
+                                    {
                                         _placement.PIDRemovePlacement(targetLMOPC.AsLMRepresentation());
                                         ReleaseCOMObjects(targetLMOPC);
                                         newOPC = _placement.PIDPlaceSymbol(targetOPC.SPPID.MAPPINGNAME, x, y, Mirror: mirror, Rotation: angle, ExistingItem: pairOPC.AsLMAItem(), TargetItem: LMConnector);
                                         _placement.PIDRemovePlacement(removeSymbol.AsLMRepresentation());
                                         ReleaseCOMObjects(removeSymbol);
                                         newOPC = _placement.PIDPlaceSymbol(symbolPath, x, y, Mirror: mirror, Rotation: angle, ExistingItem: pairOPC.AsLMAItem(), TargetItem: LMConnector);
                                         break;
+                                    }
                                     if (newOPC == null)
+                                    {
                                         foreach (LMConnector LMConnector in removeSymbol.Avoid2Connectors)
+                                        {
                                             _placement.PIDRemovePlacement(removeSymbol.AsLMRepresentation());
                                             ReleaseCOMObjects(removeSymbol);
                                             newOPC = _placement.PIDPlaceSymbol(symbolPath, x, y, Mirror: mirror, Rotation: angle, ExistingItem: pairOPC.AsLMAItem(), TargetItem: LMConnector);
                                             break;
+                                        }
+                                    }
                                     if (newOPC != null)
                                         result = true;
                                     ReleaseCOMObjects(newOPC);
                                     newOPC = null;
                                     ReleaseCOMObjects(removeSymbol);
                                     removeSymbol = null;
                                     break;
+                                }
                                 ReleaseCOMObjects(removeSymbol);
                                 removeSymbol = null;
+                            }
+                        }
+                    }
                     catch (Exception ex)
+                    {
                         Log.Write("error OPC");
+                    }
                     finally
+                    {
                         ReleaseCOMObjects(_placement);
                         _placement = null;
                         ReleaseCOMObjects(dataSource);
                         dataSource = null;
                         ReleaseCOMObjects(_FROM_OPC);
                         _FROM_OPC = null;
                         ReleaseCOMObjects(_TO_OPC);
                         _TO_OPC = null;
                         ReleaseCOMObjects(pairOPC);
                         pairOPC = null;
+                    }
+                }
                 ReleaseCOMObjects(_LMOPC);
                 ReleaseCOMObjects(pairOPC);
                 return result;
+            }
             /// <summary>
             /// Graphic OID로 해당 Symbol의 크기를 구하여 Zoom
             /// </summary>
             /// <param name="graphicOID"></param>
             /// <param name="milliseconds"></param>
             private void ZoomObjectByGraphicOID(string graphicOID, int milliseconds = 150)
+            {
                 if (radApp.ActiveDocument.ActiveSheet.DrawingObjects[graphicOID] != null)
+                {
                     double minX = 0;
                     double minY = 0;
                     double maxX = 0;
                     double maxY = 0;
                     radApp.ActiveDocument.ActiveSheet.DrawingObjects[graphicOID].Range(out minX, out minY, out maxX, out maxY);
                     radApp.ActiveWindow.ZoomArea2(minX - 0.007, minY - 0.007, maxX + 0.007, maxY + 0.007, null);
                     Thread.Sleep(milliseconds);
+                }
+            }
             private string GetSPPIDFileName(LMOPC opc)
+            {
                 string symbolPath = null;
                 foreach (LMRepresentation rep in opc.Representations)
+                {
                     if (!DBNull.Value.Equals(rep.get_FileName()) && !string.IsNullOrEmpty(rep.get_FileName()))
+                    {
                         symbolPath = rep.get_FileName();
                         break;
+                    }
+                }
                 return symbolPath;
+            }
             public void ReleaseCOMObjects(params object[] objVars)
+            {
                 int intNewRefCount = 0;
                 foreach (object obj in objVars)
                 if (objVars != null)
+                {
                     if (!Information.IsNothing(obj) && System.Runtime.InteropServices.Marshal.IsComObject(obj))
                         intNewRefCount = intNewRefCount + System.Runtime.InteropServices.Marshal.FinalReleaseComObject(obj);
                     int intNewRefCount = 0;
                     foreach (object obj in objVars)
+                    {
                         if (!Information.IsNothing(obj) && System.Runtime.InteropServices.Marshal.IsComObject(obj))
                             intNewRefCount = intNewRefCount + System.Runtime.InteropServices.Marshal.FinalReleaseComObject(obj);
+                    }
+                }
+            }
-...
                 bool result = false;
                 try
+                {
                     dynamic doc = application.Drawings.OpenDrawing(drawingName);
                     doc.Activate();
                     drawing = application.Drawings.OpenDrawing(drawingName);
                     drawing.Activate();
                     result = true;
+                }
-...
                 return result;
+            }
             private void CloseDrawing()
+            {
                 if (drawing != null)
+                {
                     drawing.CloseDrawing(true);
                     ReleaseCOMObjects(drawing);
                     drawing = null;
+                }
+            }
+        }
+    }

내보내기 Unified diff

프로젝트

일반

사용자정보

HYTOS

개정판 154d8f43