/ - Diff - MARKUS - 일정관리

ConvertService/ServiceBase/Markus.Service.Convert/ConvertService.cs
207	207	/// 작은 사이즈의 컨버팅
208	208	await Task.Factory.StartNew(new Action(() =>
209	209	{
	210	gMarkusPDF.Dispose();
210	211	result = gSaveTask.SaveFile(saveitem);
211	212
212	213	}), TaskCreationOptions.LongRunning);

                                             x =>
                                             //projectList.Contains(x.PROJECT_NO) && x.RECONVERTER < 2 &&
                                              x.RECONVERTER < 2 &&
                                             (x.STATUS == (int)StatusCodeType.None || x.STATUS == (int)StatusCodeType.FileError && x.STATUS == (int)StatusCodeType.Error))
                                             (x.STATUS == (int)StatusCodeType.None || x.STATUS == (int)StatusCodeType.FileError || x.STATUS == (int)StatusCodeType.Error))
                                         .GroupBy(x=>x.DOCUMENT_ID).Select(x => x.FirstOrDefault())
                                         .Take(TakeCount);
-...
             /// <param name="aliveItems"></param>
             /// <param name="TakeCount"></param>
             /// <returns></returns>
             public int SetCleanUpItem(string convertID)
             public int SetCleanUpItem(string convertID,int ReConvert)
+            {
                 int result = 0;
-...
+                {
                     var item = items.First();
                     item.RECONVERTER = item.RECONVERTER + 1;
                     item.RECONVERTER = item.RECONVERTER + ReConvert;
                     item.CREATE_DATETIME = DateTime.Now;
                     item.START_DATETIME = null;
                     item.END_DATETIME = null;

             /// </summary>
             /// <param name="strUri"></param>
             /// <returns></returns>
             public static bool Ping(string strUri)
             public static async Task<bool> PingAsync(string strUri)
+            {
                 bool result = false;
-...
+                    {
                         using (System.Net.Http.HttpClient Client = new System.Net.Http.HttpClient())
+                        {
                             Client.Timeout = new TimeSpan(0, 0, 10);
                             Client.Timeout = new TimeSpan(0, 1,0);
                             var task = Client.GetAsync(uri);
                             var message = await Client.GetAsync(uri);
                             if (!task.IsFaulted)
                             System.Net.Http.HttpResponseMessage responseMessage = message;
                             System.Net.HttpStatusCode StatusCode = responseMessage.StatusCode;
                             switch (StatusCode)
+                            {
                                 System.Net.Http.HttpResponseMessage responseMessage = task.Result;
                                 System.Net.HttpStatusCode StatusCode = responseMessage.StatusCode;
                                 switch (StatusCode)
+                                {
                                     case System.Net.HttpStatusCode.Accepted:
                                     case System.Net.HttpStatusCode.OK:
                                         result = true;
                                         break;
+                                }
                                 case System.Net.HttpStatusCode.Accepted:
                                 case System.Net.HttpStatusCode.OK:
                                     result = true;
                                     break;
+                            }
+                        }
+                    }

     using System.Linq;
     using System.Runtime.InteropServices;
     using System.ServiceModel;
     using System.ServiceModel.Channels;
     using System.ServiceModel.Dispatcher;
     using System.ServiceProcess;
     using System.Text;
     using System.Threading.Tasks;
-...
             private void Timer_Elapsed(object sender, ElapsedEventArgs e)
+            {
                 System.Diagnostics.Debug.WriteLine("timer : " + e?.SignalTime);
                 try
+                {
                     if (!IsReleaseItems)
+                    {
                         ReleaseItems();
+                    }
                     if ((DateTime.Now - logTime) >= new TimeSpan(0, 5, 0))
+                    {
                         logTime = DateTime.Now;
                         logger.Info("StationService Alive Check");
+                    }
+                }
                 catch (Exception ex)
+                {
                     logger.Error("Timer Error " ,ex);
+                }
                 //System.Diagnostics.Debug.WriteLine("timer : " + e?.SignalTime);
                 //try
                 //{
                 //    if (!IsReleaseItems)
                 //    {
                 //        ReleaseItems();
                 //    }
                 //    if ((DateTime.Now - logTime) >= new TimeSpan(0, 5, 0))
                 //    {
                 //        logTime = DateTime.Now;
                 //        logger.Info("StationService Alive Check");
                 //    }
                 //}
                 //catch (Exception ex)
                 //{
                 //    logger.Error("Timer Error " ,ex);
                 //}
                 System.Threading.Thread.SpinWait(1000);
                 //System.Threading.Thread.SpinWait(1000);
                 timer.Start();
                 //timer.Start();
+            }
             /// <summary>
-...
+                    {
                         //if (IsDataBaseWaitingList(1))
                         //{
                             System.Diagnostics.Debug.WriteLine("ReleaseItems start");
                             ReflashSubServiceAsync();
                         System.Diagnostics.Debug.WriteLine("ReleaseItems start");
                         ReflashSubServiceAsync();
                         if (StationServiceList.All(x => x.IsOnline))
+                        {
                             CleanUpDataBaseItems();
                             setDataBaseWaitingList();
                             System.Diagnostics.Debug.WriteLine("ReleaseItems end");
+                        }
                         else
+                        {
                             System.Diagnostics.Debug.WriteLine("Service Any Offline");
+                        }
                         System.Diagnostics.Debug.WriteLine("ReleaseItems end");
                         //}
+                    }
+                }
-...
                 logger.Info("Start ServiceStation");
                 var autoEvent = new System.Threading.AutoResetEvent(false);
                 stateTimer = new System.Threading.Timer(new System.Threading.TimerCallback(TimerCallBack), null, 0, 10000);
                 stateTimer = new System.Threading.Timer(new System.Threading.TimerCallback(TimerCallBack), null, 0, 500);
                 //timer = new System.Timers.Timer(new TimeSpan(0, 0, 0, 10).TotalMilliseconds);
                 //timer.Elapsed += Timer_Elapsed;
                 //timer.AutoReset = true;
-...
             System.Threading.Timer stateTimer;
             DateTime logTime;
             DateTime ReleaseTime;
             private void TimerCallBack(object state)
+            {
-...
                 //stateTimer.Change(-1, -1);
                 try
+                {
                     if (!IsReleaseItems)
                     if ((DateTime.Now - ReleaseTime) >= new TimeSpan(0, 0,15))
+                    {
                         ReleaseItems();
                         if (!IsReleaseItems)
+                        {
                             ReleaseItems();
+                        }
                         ReleaseTime = DateTime.Now;
+                    }
                     if ((DateTime.Now - logTime) >= new TimeSpan(0, 5, 0))
+                    {
-...
                         logger.Info("StationService Alive Check");
+                    }
+                }
                 catch (Exception ex)
+                {
                     logger.Error("Timer Error ", ex);
+                }
                 System.Threading.Thread.SpinWait(100000);
                 stateTimer.Change(0, 10000);
                 ///System.Threading.Thread.SpinWait(100000);
                 //stateTimer.Change(0, 10000);
+            }
             public void SetServiceList(List<string> serviceList)
-...
                             if (prop != null)
+                            {
                                 BasicHttpBinding myBinding = new BasicHttpBinding();
                                 BasicHttpBinding httpbinding = new BasicHttpBinding();
                                 httpbinding.CloseTimeout = new TimeSpan(0, 10, 0);
                                 httpbinding.ReceiveTimeout = new TimeSpan(0, 10, 0);
                                 httpbinding.SendTimeout = new TimeSpan(0, 10, 0);
                                 httpbinding.OpenTimeout = new TimeSpan(0, 10, 0);
                                 EndpointAddress myEndpoint = new EndpointAddress(UriHelper.UriCreate(prop.SERVICE_ADDRESS));
                                 var StationServiceClient = new WcfClient.StationServiceTask.StationServiceClient(myBinding, myEndpoint);
                                 var StationServiceClient = new WcfClient.StationServiceTask.StationServiceClient(httpbinding, myEndpoint);
                                     //var items = StationServiceClient.AliveConvertList();
-...
+            {
                 try
+                {
                     timer.Stop();
                     if (timer != null)
+                    {
                         timer.Stop();
+                    }
                     StopWcfService();
                     Stopprocess();

     # 설정된 Resolution으로 강제 변환
     # 기본 = 0
     USE_RESOLUTION = 300
     USE_RESOLUTION = 100
     # 상태 저장 간격(페이지당 상태 저장 간각)
     # 기본 5

ConvertService/ServiceBase/Markus.Service.Station/StationService/ServiceStationTask.cs
127	127	/// </summary>
128	128	public void setDataBaseWaitingList()
129	129	{
	130	List<EntityModel.CONVERTER_DOC> convertItems = new List<EntityModel.CONVERTER_DOC>();
	131
130	132	using (DataBase.ConvertDatabase database = new DataBase.ConvertDatabase(MarkusDBConnectionString))
131	133	{
132		var convertItems = database.GetWaitConvertItems(this.RunProjectList, StationServiceList.Where(x=>x.IsOnline).Sum(f=>f.Properties.PROCESS_COUNT));
	134	convertItems = database.GetWaitConvertItems(this.RunProjectList, StationServiceList.Where(x=>x.IsOnline).Sum(f=>f.Properties.PROCESS_COUNT)).ToList();
	135	}
133	136
134		foreach (var convert in convertItems)
135		{
136		//ReflashSubService();
	137	foreach (var convert in convertItems)
	138	{
	139	//ReflashSubService();
137	140
138		if (convert.STATUS > (int)StatusCodeType.None)
	141	if (convert.STATUS > (int)StatusCodeType.None)
	142	{
	143	using (DataBase.ConvertDatabase database = new DataBase.ConvertDatabase(MarkusDBConnectionString))
139	144	{
140		database.SetCleanUpItem(convert.ID);
	145	database.SetCleanUpItem(convert.ID,1);
141	146	}
142
143		PassConvertItem(convert.PROJECT_NO, convert.ID,convert.DOCUMENT_ID);
144	147	}
	148
	149	PassConvertItem(convert.PROJECT_NO, convert.ID,convert.DOCUMENT_ID);
145	150	}
	151
146	152	}
147	153
148	154	public bool IsDataBaseWaitingList(int overListCount)
...	...
175	181	{
176	182	try
177	183	{
178		subservice.IsOnline = SytemNet.Ping(subservice.Properties.SERVICE_ADDRESS);
	184	subservice.IsOnline = await SytemNet.PingAsync(subservice.Properties.SERVICE_ADDRESS);
179	185
180	186	if (subservice.IsOnline)
181	187	{
...	...
268	274
269	275	try
270	276	{
271		for (int i = convertItems.Count - 1; i >= 0; --i)
	277	if (convertItems.Count() > 0)
272	278	{
273		if (argumentList.Count(x => x == convertItems[i].ConvertID) == 0)
	279	for (int i = convertItems.Count - 1; i >= 0; --i)
274	280	{
275		AliveConvertQueue.RemoveAt(i);
	281	if (argumentList.Count(x => x == convertItems[i].ConvertID) == 0)
	282	{
	283	AliveConvertQueue.RemoveAt(i);
	284	}
276	285	}
277	286	}
278	287	}
...	...
307	316	{
308	317	if (aliveItems.Count(x => x.ConvertID == item.ID) == 0)
309	318	{
310		database.SetCleanUpItem(item.ID);
	319	database.SetCleanUpItem(item.ID,0);
311	320	}
312	321	}
313	322	}
...	...
379	388
380	389	if (IsStation)
381	390	{
382		if (!IsReleaseItems)
383		{
384		System.Diagnostics.Debug.WriteLine("ConvertFinish ReleaseItems call");
385		ReleaseItems();
386		}
	391	//if (!IsReleaseItems)
	392	//{
	393	// System.Diagnostics.Debug.WriteLine("ConvertFinish ReleaseItems call");
	394	// ReleaseItems();
	395	//}
387	396	}
388	397	else
389	398	{

         /// web service 목록
         /// </summary>
         [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
         //[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, IncludeExceptionDetailInFaults = true)]
         //[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, IncludeExceptionDetailInFaults = true)]
         public partial class ServiceStation : IStationService
+        {
             /// <summary>

                    foreach (var item in serviceUri.Split(','))
+                    {
                         BasicHttpBinding myBinding = new BasicHttpBinding();
                         BasicHttpBinding httpbinding = new BasicHttpBinding();
                         httpbinding.CloseTimeout = new TimeSpan(0, 10, 0);
                         httpbinding.ReceiveTimeout = new TimeSpan(0, 10, 0);
                         httpbinding.SendTimeout = new TimeSpan(0, 10, 0);
                         httpbinding.OpenTimeout = new TimeSpan(0, 10, 0);
                         EndpointAddress myEndpoint = new EndpointAddress(UriHelper.UriCreate(item));
                         var StationClient = new StationServiceClient(myBinding, myEndpoint);
                         var StationClient = new StationServiceClient(httpbinding, myEndpoint);
                         StationClientList.Add(StationClient);
+                    }

     using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
     using System.Windows;
     using System.Windows.Controls;
     using System.Windows.Documents;
     namespace Markus.Service.StationController.Behaviors
+    {
         public class RichTextBoxBehaviors : DependencyObject
+        {
             public static FlowDocument GetDocument(DependencyObject obj)
+            {
                 return (FlowDocument)obj.GetValue(DocumentProperty);
+            }
             public static void SetDocument(DependencyObject obj, FlowDocument value)
+            {
                 obj.SetValue(DocumentProperty, value);
+            }
             public static readonly DependencyProperty DocumentProperty = DependencyProperty.RegisterAttached("Document", typeof(FlowDocument), typeof(RichTextBoxBehaviors),
                                                                         new FrameworkPropertyMetadata(null, new PropertyChangedCallback(DocumentPropertyChanged)) { BindsTwoWayByDefault = true });
             private static void DocumentPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+            {
                 var richTextBox = (RichTextBox)d;
                 //richTextBox.Document.Dispatcher.InvokeAsync(() =>
                 //{
                 //    if (e.NewValue != null)
                 //    {
                 //        var doc = (e.NewValue == null) ? new FlowDocument() : (FlowDocument)e.NewValue;
                 //        if (richTextBox.Document == null)
                 //        {
                 //            richTextBox.Document = new FlowDocument();
                 //        }
                 //        richTextBox.Document.Blocks doc.Blocks
                 //    }
                 //});
+            }
             public FlowDocument Document
+            {
                 get { return (FlowDocument)GetValue(DocumentProperty); }
                 set { SetValue(DocumentProperty, value); }
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Diagnostics;
     namespace Markus.Service.Controls
+    {
     	interface ITraceTextSink
+    	{
     		void Fail(string msg);
     		void Event(string msg, TraceEventType eventType);
+    	}
+    }

     <FlowDocument  x:Class="Markus.Service.Controls.TraceDocument"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    FontSize="12" FontFamily="Courier New" PageWidth="10000"  Loaded="Document_Loaded" Unloaded="Document_Unloaded">
         <FlowDocument.Resources>
             <Style TargetType="{x:Type Run}" x:Key="Information">
                 <Setter Property="Foreground" Value="Black"/>
                 <Setter Property="FontWeight" Value="Normal"/>
             </Style>
             <Style TargetType="{x:Type Run}" x:Key="Error">
                 <Setter Property="Foreground" Value="Red"/>
                 <Setter Property="FontWeight" Value="Bold"/>
             </Style>
             <Style TargetType="{x:Type Run}" x:Key="Warning">
                 <Setter Property="Foreground" Value="Red"/>
                 <Setter Property="FontWeight" Value="Normal"/>
             </Style>
             <Style TargetType="{x:Type Run}" x:Key="Fail">
                 <Setter Property="Foreground" Value="Fuchsia"/>
                 <Setter Property="FontWeight" Value="Bold"/>
             </Style>
         </FlowDocument.Resources>
         <Paragraph>
         </Paragraph>
     </FlowDocument>

     using System.Windows.Controls;
     using System.Windows;
     using System.Windows.Media;
     using System.Windows.Documents;
     using System.Diagnostics;
     using System.Windows.Controls.Primitives;
     namespace Markus.Service.Controls
+    {
         public partial class TraceDocument : FlowDocument, ITraceTextSink
+        {
             private delegate void AppendTextDelegate(string msg, string style);
             private TraceListener _listener;
             public TraceDocument()
+            {
                 AutoAttach = true;
                 InitializeComponent();
+            }
             public bool AutoAttach { get; set; }
             public void Event(string msg, TraceEventType eventType)
+            {
                 Append(msg, eventType.ToString());
+            }
             public void Fail(string msg)
+            {
                 Append(msg, "Fail");
+            }
             private void Append(string msg, string style)
+            {
                 if (Dispatcher.CheckAccess())
+                {
                     Debug.Assert(Blocks.LastBlock != null);
                     Debug.Assert(Blocks.LastBlock is Paragraph);
                     var run = new Run(msg);
                     run.Style = (Style)(Resources[style]);
                     if (run.Style == null)
                         run.Style = (Style)(Resources["Information"]);
                     ((Paragraph)Blocks.LastBlock).Inlines.Add(run);
                     ScrollParent(this);
+                }
                 else
+                {
                     Dispatcher.Invoke(new AppendTextDelegate(Append), msg, style);
+                }
+            }
             private static void ScrollParent(FrameworkContentElement element)
+            {
                 if (element != null)
+                {
                     if (element.Parent is TextBoxBase)
                         ((TextBoxBase)element.Parent).ScrollToEnd();
                     else if (element.Parent is ScrollViewer)
                         ((ScrollViewer)element.Parent).ScrollToEnd();
                     else
                         ScrollParent(element.Parent as FrameworkContentElement);
+                }
+            }
             private void Document_Loaded(object sender, RoutedEventArgs e)
+            {
                 if (AutoAttach && _listener == null)
+                {
                     _listener = new TraceTextSource(this);
                     Trace.Listeners.Add(_listener);
+                }
+            }
             private void Document_Unloaded(object sender, RoutedEventArgs e)
+            {
                 if (_listener != null)
+                {
                     Trace.Listeners.Remove(_listener);
                     _listener.Dispose();
                     _listener = null;
+                }
+            }
+        }
+    }

     using System;
     using System.Diagnostics;
     namespace Markus.Service.Controls
+    {
         class TraceTextSource : TraceListener
+        {
             public ITraceTextSink Sink { get; private set; }
             private bool _fail;
             private TraceEventType _eventType = TraceEventType.Information;
             public TraceTextSource(ITraceTextSink sink)
+            {
                 Debug.Assert(sink != null);
                 Sink = sink;
+            }
             public override void Fail(string message)
+            {
                 _fail = true;
                 base.Fail(message);
+            }
             public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
+            {
                 //_eventType = eventType;
                // base.TraceEvent(eventCache, source, eventType, id, message);
+            }
             public override void Write(string message)
+            {
                 if (IndentLevel > 0)
                     message = message.PadLeft(IndentLevel + message.Length, '\t');
                 if (_fail)
                     Sink.Fail(message);
                 else
                     Sink.Event(message, _eventType);
                 _fail = false;
                 _eventType = TraceEventType.Information;
+            }
             public override void WriteLine(string message)
+            {
                 Write(message + "\n");
+            }
+        }
+    }

         </ApplicationDefinition>
         <Compile Include="AppInit.cs" />
         <Compile Include="AppDefine.cs" />
         <Compile Include="Behaviors\RichTextBoxBehaviors.cs" />
         <Compile Include="Behaviors\StatusTypeSet.cs" />
         <Compile Include="Controls\ITraceTextSink.cs" />
         <Compile Include="Controls\TraceDocument.xaml.cs">
           <DependentUpon>TraceDocument.xaml</DependentUpon>
         </Compile>
         <Compile Include="Controls\TraceTextSource.cs" />
         <Compile Include="Data\NavigationItem.cs" />
         <Compile Include="Extensions\ConvertItemChangeValue.cs" />
         <Compile Include="Extensions\GetStatusTypeEnums.cs" />
-...
         <Compile Include="Views\SettingsView.xaml.cs">
           <DependentUpon>SettingsView.xaml</DependentUpon>
         </Compile>
         <Page Include="Controls\TraceDocument.xaml">
           <Generator>MSBuild:Compile</Generator>
           <SubType>Designer</SubType>
         </Page>
         <Page Include="MainWindow.xaml">
           <Generator>MSBuild:Compile</Generator>
           <SubType>Designer</SubType>

ConvertService/ServiceBase/Markus.Service.StationController/StationController.ini
1	1	[SERVICE]
2	2	SERVICE_ADDRESS = http://172.20.120.142:9991/StationService,http://172.20.120.143:9991/StationService
	3
	4	# http://172.20.120.142:9991/StationService,http://172.20.120.143:9991/StationService
3	5	#,http://192.168.0.68:9101/StationService
4	6	#http://172.20.120.142:9991/StationService
5	7

             private System.Collections.ObjectModel.ObservableCollection<ConvertItem> aliveItems;
             private bool isLoading;
             private System.Windows.Documents.FlowDocument connectionLog;
             public System.Collections.ObjectModel.ObservableCollection<ConvertItem> AliveItems
+            {
-...
+                }
+            }
             public System.Windows.Documents.FlowDocument ConnectionLog
+            {
                 get => connectionLog;
                 set
+                {
                     if(connectionLog != value)
+                    {
                         connectionLog = value;
                         OnPropertyChanged(() => ConnectionLog);
+                    }
+                }
+            }
             public AliveViewModel()
+            {
+            }
-...
+            {
                 while (IsAcitve)
+                {
                     System.Threading.Thread.Sleep(5000);
                     System.Threading.Thread.Sleep(new TimeSpan(0,0,3));
                     try
                     if (!IsLoading)
+                    {
                         IsLoading = true;
                         List<ConvertItem> newitems = new List<ConvertItem>();
                         foreach (var client in App.StationClientList)
                         try
+                        {
                             //if (SimplePing(client.Endpoint.Address.ToString()))
                             //{
                             try
+                            {
                                 var items = await client.AliveConvertListAsync();
                                 newitems.AddRange(items);
+                            }
                             catch (Exception ex)
                             List<ConvertItem> newitems = new List<ConvertItem>();
                             foreach (var client in App.StationClientList)
+                            {
                                 System.Diagnostics.Debug.WriteLine(ex.ToString());
                                 if (await SimplePingAsync(client.Endpoint.Address.ToString()))
+                                {
                                     try
+                                    {
                                         var items = await client.AliveConvertListAsync();
                                         newitems.AddRange(items);
                                         System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} ping");
                                         if (items.Count() == 0)
+                                        {
                                             System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} Alive Items is zero.");
+                                        }
+                                    }
                                     catch (Exception ex)
+                                    {
                                         System.Diagnostics.Trace.TraceError($"{client.Endpoint.Address} {ex.Message}");
+                                    }
+                                }
                                 else
+                                {
                                     System.Diagnostics.Trace.TraceError($"{client.Endpoint.Address} ping Error");
+                                }
+                            }
                             //}
+                        }
                         foreach (var item in newitems)
                             ItemsUpdate(newitems);
+                        }
                         catch (Exception ex)
+                        {
                             item.OriginfilePath = HttpUtility.UrlDecode(item.OriginfilePath);
+                        }
                         if (AliveItems == null)
+                        {
                             AliveItems = new System.Collections.ObjectModel.ObservableCollection<ConvertItem>();
                         IsLoading = false;
+                    }
                             foreach (var item in newitems)
+                            {
                                 AliveItems.Add(item);
+                            }
+                        }
                         else
+                        {
                             /// 데이터 업데이트
                             newitems.ForEach(newitem =>
+                            {
                                 AliveItems.UpdateWhere(changeitem => ConvertItemEx.ChangeValues(changeitem, newitem), x => x.ProjectNumber == newitem.ProjectNumber && x.ConvertID == newitem.ConvertID);
                             });
+                }
+            }
                             // 추가
                             foreach (var item in newitems)
+                            {
                                 if (AliveItems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)
+                                {
                                     AliveItems.Add(item);
+                                }
+                            }
                             /// 삭제
             private void ItemsUpdate(List<ConvertItem> newitems)
+            {
                             for (int i = AliveItems.Count() -1; i > -1; --i)
+                            {
                                 var item = AliveItems[i];
                 foreach (var item in newitems)
+                {
                     item.OriginfilePath = HttpUtility.UrlDecode(item.OriginfilePath);
+                }
                                 if (newitems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)
+                                {
                                     AliveItems.RemoveAt(i);
+                                }
+                            }
                 if (AliveItems == null)
+                {
                     AliveItems = new System.Collections.ObjectModel.ObservableCollection<ConvertItem>();
                     foreach (var item in newitems)
+                    {
                         AliveItems.Add(item);
+                    }
+                }
                 else
+                {
                     /// 데이터 업데이트
                     newitems.ForEach(newitem =>
+                    {
                         AliveItems.UpdateWhere(changeitem => ConvertItemEx.ChangeValues(changeitem, newitem), x => x.ProjectNumber == newitem.ProjectNumber && x.ConvertID == newitem.ConvertID);
                     });
                     // 추가
                     foreach (var item in newitems)
+                    {
                         if (AliveItems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)
+                        {
                             AliveItems.Add(item);
+                        }
+                    }
                     catch (Exception ex)
                     /// 삭제
                     for (int i = AliveItems.Count() - 1; i > -1; --i)
+                    {
                         var item = AliveItems[i];
                         if (newitems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)
+                        {
                             AliveItems.RemoveAt(i);
+                        }
+                    }
+                }
+            }
             private void LogWrite(string log,bool IsError)
+            {
                 if(IsError)
+                {
                     System.Diagnostics.Trace.Fail(log);
+                }
                 else
+                {
                     System.Diagnostics.Trace.TraceInformation(log);
+                }
+            }
             public static bool SimplePing(string uri)
             public static async Task<bool> SimplePingAsync(string uri)
+            {
                 bool result = false;
-...
+                {
                     using (System.Net.Http.HttpClient Client = new System.Net.Http.HttpClient())
+                    {
                         Client.Timeout = new TimeSpan(0, 0, 10);
                         Client.Timeout = new TimeSpan(0, 5,0);
                         var message = await Client.GetAsync(uri);
                         System.Net.Http.HttpResponseMessage responseMessage = Client.GetAsync(uri).Result;
                         System.Net.HttpStatusCode StatusCode = responseMessage.StatusCode;
                         System.Net.HttpStatusCode StatusCode = message.StatusCode;
                         switch (StatusCode)
+                        {
-...
+                        }
+                    }
+                }
                 catch (Exception)
                 catch (Exception ex)
+                {
                     result = false;
+                }
                 return result;

                  xmlns:telerik="http://schemas.telerik.com/2008/xaml/presentation"
                   xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
                   xmlns:vm="clr-namespace:Markus.Service.StationController.ViewModel"
                  d:DesignHeight="450" d:DesignWidth="800">
                  xmlns:Behaviors="clr-namespace:Markus.Service.StationController.Behaviors"
                  xmlns:controls="clr-namespace:Markus.Service.Controls" Background="White"
                  d:DesignHeight="800" d:DesignWidth="800">
         <UserControl.DataContext>
             <vm:AliveViewModel/>
         </UserControl.DataContext>
-...
         </i:Interaction.Triggers>
         <Grid>
             <Grid.RowDefinitions>
                 <RowDefinition Height="*"/>
                 <RowDefinition Height="7*"/>
                 <RowDefinition Height="3*" MinHeight="150" MaxHeight="300"/>
                 <RowDefinition Height="Auto"/>
             </Grid.RowDefinitions>
             <telerik:RadGridView ItemsSource="{Binding AliveItems}" AutoGenerateColumns="False"
-...
                     <telerik:GridViewDataColumn  Header="Output Path" DataMemberBinding="{Binding ConvertPath}"/>
                 </telerik:RadGridView.Columns>
             </telerik:RadGridView>
             <ProgressBar Grid.Row="1" IsIndeterminate="{Binding IsLoading}" Height="5"/>
             <!--<GroupBox Header="ServiceStation Connection Log" Background="White"  Grid.Row="1" Margin="3" BorderThickness="0">-->
                 <Grid  Grid.Row="1">
                 <RichTextBox IsReadOnly="True" AllowDrop="False" VerticalScrollBarVisibility="Visible"
                              IsUndoEnabled="False" HorizontalScrollBarVisibility="Auto"
                              Height="{Binding ActualHeight, Mode=OneWay, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Grid}}}"
                              Width="{Binding ActualWidth, Mode=OneWay, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Grid}}}">
                     <controls:TraceDocument PageWidth="{Binding ActualWidth, Mode=OneWay, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Grid}}}"
                                             PageHeight="{Binding ActualHeight, Mode=OneWay, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Grid}}}"/>
                 </RichTextBox>
                 </Grid>
             <!--</GroupBox>-->
             <ProgressBar Grid.Row="2" IsIndeterminate="{Binding IsLoading}" Height="5"/>
         </Grid>
     </UserControl>

                 if (HttpHostEndpoint != null)
+                {
                     Binding httpbinding = new BasicHttpBinding();
                     Binding httpbinding = new BasicHttpBinding { TransferMode = TransferMode.Buffered};
                     httpbinding.CloseTimeout = new TimeSpan(0, 10, 0);
                     httpbinding.ReceiveTimeout = new TimeSpan(0, 10, 0);
                     httpbinding.SendTimeout = new TimeSpan(0, 10, 0);
                     httpbinding.OpenTimeout = new TimeSpan(0, 10, 0);
                     Binding bindingMex = MetadataExchangeBindings.CreateMexHttpBinding();
                     bindingMex.CloseTimeout = new TimeSpan(0, 10, 0);
                     bindingMex.ReceiveTimeout = new TimeSpan(0, 10, 0);
                     bindingMex.SendTimeout = new TimeSpan(0, 10, 0);
                     bindingMex.OpenTimeout = new TimeSpan(0, 10, 0);
                     httpbinding.CreateBindingElements().Add(gBindingElement);
-...
+                }
                 var behavior = serviceHost.Description.Behaviors.Find<ServiceBehaviorAttribute>();
                 behavior.ConcurrencyMode = ConcurrencyMode.Multiple;
                 behavior.InstanceContextMode = InstanceContextMode.Single;
                 serviceHost.Open();
-...
                     MaxNameTableCharCount = Int32.MaxValue
                 };
+            }
             //rest 추가로 변경
             private static ServiceHost WcfCreate_old(this ServiceHost serviceHost, object service, Type serviceInterface, IEnumerable<Uri> HostEndpoints)
+            {
                 if (serviceHost != null)
+                {
                     foreach (var item in serviceHost.ChannelDispatchers)
+                    {
                         item.Abort();
+                    }
                     serviceHost.Abort();
                     serviceHost = null;
+                }
                 serviceHost = new ServiceHost(service, HostEndpoints.ToArray());
                 if (HostEndpoints.GroupBy(f => f.Scheme).Count() != HostEndpoints.Count())
+                {
                     throw new Exception("Host Uri's schema must be unique.");
+                }
                 ServiceMetadataBehavior mBehave = new ServiceMetadataBehavior();
                 mBehave.HttpGetEnabled = true;
                 mBehave.HttpsGetEnabled = true;
                 serviceHost.Description.Behaviors.Add(mBehave);
                 //ServiceBehaviorAttribute attribute = new ServiceBehaviorAttribute();
                 //attribute.InstanceContextMode = InstanceContextMode.Single;
                 //attribute.IncludeExceptionDetailInFaults = false;
                 //serviceHost.Description.Behaviors.Add(attribute);
                 //ServiceDebugBehavior sdb = serviceHost.Description.Behaviors.Find<ServiceDebugBehavior>();
                 //sdb.IncludeExceptionDetailInFaults = true;
                 foreach (var item in HostEndpoints)
+                {
                     System.ServiceModel.Channels.Binding binding = null;
                     System.ServiceModel.Channels.Binding bindingMex = null;
                     if (item.Scheme == Uri.UriSchemeHttp)
+                    {
                         binding = new BasicHttpBinding();
                         bindingMex = MetadataExchangeBindings.CreateMexHttpBinding();
                         BindingElementCollection bindElemColl = new BindingElementCollection();
                         BinaryMessageEncodingBindingElement bindElem = new BinaryMessageEncodingBindingElement();
                         bindElem.MaxReadPoolSize = 64;
                         bindElem.MaxWritePoolSize = 16;
                         bindElem.MaxSessionSize = 2048;
                         XmlDictionaryReaderQuotas readerQuotas = new XmlDictionaryReaderQuotas();
                         readerQuotas.MaxDepth = 32;
                         readerQuotas.MaxStringContentLength = Int32.MaxValue;
                         readerQuotas.MaxArrayLength = Int32.MaxValue;
                         readerQuotas.MaxBytesPerRead = Int32.MaxValue;
                         readerQuotas.MaxNameTableCharCount = Int32.MaxValue;
                         bindElem.ReaderQuotas = readerQuotas;
                         binding.CreateBindingElements().Add(bindElem);
+                    }
                     else if (item.Scheme == Uri.UriSchemeHttps)
+                    {
                         binding = new BasicHttpsBinding();
                         bindingMex = MetadataExchangeBindings.CreateMexHttpsBinding();
+                    }
                     else if (item.Scheme == Uri.UriSchemeNetTcp)
+                    {
                         binding = new NetTcpBinding();
                         bindingMex = MetadataExchangeBindings.CreateMexTcpBinding();
+                    }
                     else
+                    {
                         throw new Exception($"{item.ToString()} is Not Support Schema.");
+                    }
                     var endpoint = serviceHost.AddServiceEndpoint(serviceInterface, binding, item);
                     if (binding is BasicHttpBinding)
+                    {
                         WebHttpBinding webHttp = new WebHttpBinding();
                         var serviceEndpoint = serviceHost.AddServiceEndpoint(serviceInterface, webHttp, item);
                         serviceEndpoint.EndpointBehaviors.Add(new WebHttpBehavior());
+                    }
                     serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), bindingMex, "mex");
+                }
                 var behavior = serviceHost.Description.Behaviors.Find<ServiceBehaviorAttribute>();
                 behavior.InstanceContextMode = InstanceContextMode.Single;
                 serviceHost.Open();
                 return serviceHost;
+            }
+        }
+    }

ID	1ae729e493a9e9a23d51cbaabb29993365c56ce6
상위	60723dc9
하위	a34f58f6

프로젝트

일반

사용자정보

MARKUS

개정판 1ae729e4