source: BMXNET_RPMS_dotNET_UTILITIES-BMX/trunk/cs/bmx_0200scr/BMX2/BMXNet/BMXNetConnectInfo.cs@ 907

Last change on this file since 907 was 822, checked in by Sam Habiel, 15 years ago

Support for other encodings besides ASCII. Constructors available in BMXNetLib and and BMXNetConnectInfo.
Comments in several files.
File size: 32.7 KB
Line 
1using System;
2using System.Data;
3using System.Diagnostics;
4using System.IO;
5using System.IO.IsolatedStorage;
6using System.Runtime.Serialization;
7using System.Runtime.Serialization.Formatters;
8using System.Runtime.Serialization.Formatters.Soap;
9using System.Windows.Forms;
10using System.Security.Principal;
11using System.Text;
12using System.Security.Cryptography;
13using System.Timers;
14using System.Threading;
15
16
17namespace IndianHealthService.BMXNet
18{
19 public class BMXNetEventArgs : EventArgs
20 {
21 public string BMXParam;
22 public string BMXEvent;
23 }
24
25 /// <summary>
26 /// Contains methods and properties to support RPMS Login for .NET applications
27 /// </summary>
28 public class BMXNetConnectInfo : System.Windows.Forms.Control
29 {
30
31 /// <summary>
32 /// Serializes RPMS server address and port
33 /// </summary>
34 [SerializableAttribute]
35 private class ServerData
36 {
37 public string m_sAddress = "";
38 public int m_nPort = 0;
39 public string m_sNamespace = "";
40
41 public ServerData()
42 {
43 }
44
45 public ServerData(string sAddress, int nPort)
46 {
47 this.m_nPort = nPort;
48 this.m_sAddress = sAddress;
49 this.m_sNamespace = "";
50 }
51 public ServerData(string sAddress, int nPort, string sNamespace)
52 {
53 this.m_nPort = nPort;
54 this.m_sAddress = sAddress;
55 this.m_sNamespace = sNamespace;
56 }
57 }
58
59 /// <summary>
60 /// BMXNetConnector With Default Encoding (invokes BMXNetLib)
61 /// </summary>
62 public BMXNetConnectInfo() : this("") { }
63
64 /// <summary>
65 /// BMXNetConnector with a specific encoding
66 /// </summary>
67 /// <param name="encoding">String representation of encoding (e.g. windows-1256 for arabic).
68 /// If encoding is not found, we fall back to the default windows encoding. A debug message
69 /// is printed to that effect.</param>
70 public BMXNetConnectInfo(string encoding)
71 {
72 if (encoding == String.Empty) m_BMXNetLib = new BMXNetLib();
73 else m_BMXNetLib = new BMXNetLib(encoding);
74
75 m_timerEvent = new System.Timers.Timer();
76 m_timerEvent.Elapsed += new ElapsedEventHandler(OnEventTimer);
77 m_timerEvent.Interval = 10000;
78 m_timerEvent.Enabled = false;
79 }
80
81 #region BMXNetEvent
82
83 private System.Timers.Timer m_timerEvent;
84 public delegate void BMXNetEventDelegate(Object obj, BMXNetEventArgs e);
85 public event BMXNetEventDelegate BMXNetEvent;
86
87 /// <summary>
88 /// Enables and disables event polling for the RPMS connection
89 /// </summary>
90 public bool EventPollingEnabled
91 {
92 get
93 {
94 return m_timerEvent.Enabled;
95 }
96 set
97 {
98// Debug.Write("ConnectInfo handle: " + this.Handle.ToString() + "\n");
99 //System.IntPtr pHandle = this.Handle;
100 m_timerEvent.Enabled = value;
101 }
102 }
103
104 /// <summary>
105 /// Sets and retrieves the interval in milliseconds for RPMS event polling
106 /// </summary>
107 public double EventPollingInterval
108 {
109 get
110 {
111 return m_timerEvent.Interval;
112 }
113 set
114 {
115 m_timerEvent.Interval = value;
116 }
117 }
118
119 /// <summary>
120 /// Register interest in an RPMS event.
121 /// </summary>
122 /// <param name="EventName"></param>
123 /// <returns></returns>
124 public int SubscribeEvent(string EventName)
125 {
126 try
127 {
128 //System.IntPtr pHandle = this.Handle;
129 DataTable dt;
130 RPMSDataTableDelegate rdtd = new RPMSDataTableDelegate(RPMSDataTable);
131 if (this.IsHandleCreated == false)
132 {
133 this.CreateHandle();
134 }
135 dt = (DataTable) this.Invoke(rdtd, new object[] {"BMX EVENT REGISTER^" + EventName, "dt"});
136
137// dt = RPMSDataTable("BMX EVENT REGISTER^" + EventName, "dt");
138 DataRow dr = dt.Rows[0];
139 int nRet = (int) dr["ERRORID"];
140 return nRet;
141 }
142 catch (Exception ex)
143 {
144 Debug.Write(ex.Message);
145 return 99;
146 }
147 }
148
149 /// <summary>
150 /// Unregister an RPMS event
151 /// </summary>
152 /// <param name="EventName"></param>
153 /// <returns></returns>
154 public int UnSubscribeEvent(string EventName)
155 {
156 try
157 {
158 DataTable dt;
159 RPMSDataTableDelegate rdtd = new RPMSDataTableDelegate(RPMSDataTable);
160 if (this.IsHandleCreated == false)
161 {
162 this.CreateHandle();
163 }
164 dt = (DataTable) this.Invoke(rdtd, new object[] {"BMX EVENT UNREGISTER^" + EventName, "dt"});
165
166 DataRow dr = dt.Rows[0];
167 int nRet = (int) dr["ERRORID"];
168 return nRet;
169 }
170 catch (Exception ex)
171 {
172 Debug.Write(ex.Message);
173 return 99;
174 }
175 }
176
177 /// <summary>
178 /// Raise an RPMS event
179 /// </summary>
180 /// <param name="EventName">The name of the event to raise</param>
181 /// <param name="Param">Parameters associated with the event</param>
182 /// <param name="RaiseBack">True if the event should be raised back to the caller</param>
183 /// <returns></returns>
184 public int RaiseEvent(string EventName, string Param, bool RaiseBack)
185 {
186 string sBack = (RaiseBack == true)?"TRUE":"FALSE";
187 try
188 {
189 DataTable dt;
190 RPMSDataTableDelegate rdtd = new RPMSDataTableDelegate(RPMSDataTable);
191 if (this.IsHandleCreated == false)
192 {
193 this.CreateHandle();
194 }
195 dt = (DataTable) this.Invoke(rdtd, new object[] {"BMX EVENT RAISE^" + EventName + "^" + Param + "^" + sBack + "^", "dt"});
196
197 DataRow dr = dt.Rows[0];
198 int nRet = (int) dr["ERRORID"];
199 return nRet;
200 }
201 catch (Exception ex)
202 {
203 Debug.Write(ex.Message);
204 return 99;
205 }
206 }
207
208 /// <summary>
209 /// Sets and retrieves the number of times that the Event Timer will generage a BMXNet AutoFire event.
210 /// For example, if AutoFire == 3, then every 3rd time the Event Timer fires, it will generate an AutoFire event.
211 /// </summary>
212 public int AutoFire
213 {
214 get
215 {
216 return m_nAutoFireIncrements;
217 }
218 set
219 {
220 m_nAutoFireIncrements = value;
221 }
222 }
223
224 //Retrieve events registered by this session
225 private int m_nAutoFireIncrements = 0;
226 private int m_nAutoFireCount = 0;
227
228 private void OnEventTimer(object source, ElapsedEventArgs e)
229 {
230 try
231 {
232 this.bmxNetLib.BMXRWL.AcquireWriterLock(5);
233 try
234 {
235 this.m_timerEvent.Enabled = false;
236
237 Object obj = this;
238 BMXNetEventArgs args = new BMXNetEventArgs();
239 m_nAutoFireCount++;
240 if ((m_nAutoFireIncrements > 0)&&(m_nAutoFireCount >= m_nAutoFireIncrements))
241 {
242 m_nAutoFireCount = 0;
243 args.BMXEvent = "BMXNet AutoFire";
244 args.BMXParam = "";
245 if (BMXNetEvent != null)
246 {
247 BMXNetEvent(obj, args);
248 }
249 this.m_timerEvent.Enabled = true;
250 return;
251 }
252
253 if (m_BMXNetLib.Connected == false)
254 {
255 this.m_timerEvent.Enabled = true;
256 return;
257 }
258
259 DataTable dtEvents = new DataTable("BMXNetEvents");
260
261 try
262 {
263 if (this.IsHandleCreated == false)
264 {
265 this.CreateHandle();
266 }
267 RPMSDataTableDelegate rdtd = new RPMSDataTableDelegate(RPMSDataTable);
268 dtEvents = (DataTable) this.Invoke(rdtd, new object[] {"BMX EVENT POLL", "BMXNetEvents"});
269 }
270 catch (Exception ex)
271 {
272 string sMsg = ex.Message;
273 this.m_timerEvent.Enabled = true;
274 return;
275 }
276
277 try
278 {
279 if (dtEvents.Rows.Count == 0)
280 {
281 this.m_timerEvent.Enabled = true;
282 return;
283 }
284 }
285 catch(Exception ex)
286 {
287 Debug.Write("upper Exception in BMXNetConnectInfo.OnEventTimer: " + ex.Message + "\n");
288 }
289 try
290 {
291 //If events exist, raise BMXNetEvent
292 foreach (DataRow dr in dtEvents.Rows)
293 {
294 args.BMXEvent = dr["EVENT"].ToString();
295 args.BMXParam = dr["PARAM"].ToString();
296 if (BMXNetEvent != null)
297 {
298 BMXNetEvent(obj, args);
299 }
300 }
301 this.m_timerEvent.Enabled = true;
302 return;
303 }
304 catch(Exception ex)
305 {
306 Debug.Write("lower Exception in BMXNetConnectInfo.OnEventTimer: " + ex.Message + "\n");
307 }
308 }
309 catch(Exception ex)
310 {
311 Debug.Write("Exception in BMXNetConnectInfo.OnEventTimer: " + ex.Message + "\n");
312 }
313 finally
314 {
315 this.bmxNetLib.BMXRWL.ReleaseWriterLock();
316 this.m_timerEvent.Enabled = true;
317 }
318 }
319 catch
320 {
321 Debug.Write(" OnEventTimer failed to obtain lock.\n");
322 }
323 }
324
325 #endregion BMXNetEvent
326
327 #region Fields
328
329 private ServerData m_ServerData;
330 private string m_sServerAddress;
331 private int m_nServerPort;
332 private string m_sServerNamespace;
333 private string m_sDUZ2;
334 private int m_nDivisionCount = 0;
335 private string m_sUserName;
336 private string m_sDivision;
337 private string m_sAppcontext;
338 private BMXNetLib m_BMXNetLib;
339 private bool m_bAutoServer = false;
340 private bool m_bAutoLogin = false;
341
342 #endregion Fields
343
344 #region Properties
345
346// /// <summary>
347// /// Set and retrieve the timeout in milliseconds for locking the transmit port.
348// /// If the transmit port is unavailable an ApplicationException will be thrown.
349// /// </summary>
350// public int TransmitLockTimeout
351// {
352// get
353// {
354// return m_nTransmitLockTimeout;
355// }
356// set
357// {
358// m_nTransmitLockTimeout = value;
359// }
360// }
361
362 /// <summary>
363 /// Set and retrieve the timeout, in milliseconds, to receive a response from the RPMS server.
364 /// If the retrieve time exceeds the timeout, an exception will be thrown and the connection will be closed.
365 /// The default is 30 seconds.
366 /// </summary>
367 public int ReceiveTimeout
368 {
369 get { return m_BMXNetLib.ReceiveTimeout; }
370 set { m_BMXNetLib.ReceiveTimeout = value; }
371 }
372
373 public string MServerNameSpace
374 {
375 get
376 {
377 return m_BMXNetLib.MServerNamespace;
378 }
379 set
380 {
381 m_BMXNetLib.MServerNamespace = value;
382 }
383 }
384
385 public BMXNetLib bmxNetLib
386 {
387 get
388 {
389 return m_BMXNetLib;
390 }
391 }
392
393 public string AppContext
394 {
395 get
396 {
397 return m_sAppcontext;
398 }
399 set
400 {
401 if (m_BMXNetLib.Connected == true)
402 {
403 try
404 {
405 try
406 {
407 m_BMXNetLib.AppContext = value;
408 m_sAppcontext = value;
409 }
410 catch (Exception ex)
411 {
412 Debug.Write(ex.Message);
413 throw ex;
414 }
415 finally
416 {
417 }
418 }
419 catch (ApplicationException aex)
420 {
421 // The writer lock request timed out.
422 Debug.Write("BMXNetConnectInfo.AppContext lock request timed out.\n");
423 throw aex;
424 }
425 }//end if
426 }//end set
427 }
428
429 public bool Connected
430 {
431 get
432 {
433 return m_BMXNetLib.Connected;
434 }
435 }
436
437 public string UserName
438 {
439 get
440 {
441 return this.m_sUserName;
442 }
443 }
444
445 public string DivisionName
446 {
447 get
448 {
449 return this.m_sDivision;
450 }
451 }
452
453 /// <summary>
454 /// Returns a string representation of DUZ
455 /// </summary>
456 public string DUZ
457 {
458 get
459 {
460 return this.bmxNetLib.DUZ;
461 }
462 }
463
464 /// <summary>
465 /// Sets and Returns DUZ(2)
466 /// </summary>
467 public string DUZ2
468 {
469 get
470 {
471 return m_sDUZ2;
472 }
473 set
474 {
475 try
476 {
477 //Set DUZ(2) in M partition
478 DataTable dt = this.RPMSDataTable("BMXSetFac^" + value, "SetDUZ2");
479 Debug.Assert(dt.Rows.Count == 1);
480 DataRow dr = dt.Rows[0];
481 string sDUZ2 = dr["FACILITY_IEN"].ToString();
482 if (sDUZ2 != "0")
483 {
484 m_sDUZ2 = sDUZ2;
485 this.m_sDivision = dr["FACILITY_NAME"].ToString();
486 }
487 }
488 catch (Exception ex)
489 {
490 Debug.Write("DUZ2.Set failed: " + ex.Message + "\n");
491 }
492 }
493 }
494
495 /// <summary>
496 /// Gets the address of the RPMS Server
497 /// </summary>
498 public string MServerAddress
499 {
500 get
501 {
502 return this.m_sServerAddress;
503 }
504 }
505
506 /// <summary>
507 /// Gets the port on which the MServer is connected
508 /// </summary>
509 public int MServerPort
510 {
511 get
512 {
513 return this.m_nServerPort;
514 }
515 }
516
517 public DataTable UserDivisions
518 {
519 get
520 {
521 DataTable dt = this.GetUserDivisions();
522 return dt;
523 }
524 }
525
526 #endregion Properties
527
528 #region Methods
529
530 public void CloseConnection()
531 {
532 //TODO: Make thread safe
533 this.m_bAutoServer = false;
534 this.m_bAutoLogin = false;
535 m_BMXNetLib.CloseConnection();
536 }
537
538 /// <summary>
539 /// For backwards compatibility. Internally calls LoadConnectInfo()
540 /// </summary>
541 public void Login()
542 {
543 LoadConnectInfo();
544 }
545
546 /// <summary>
547 /// Change the internet address and port of the RPMS server
548 /// Throws a BMXNetException if user cancels
549 /// </summary>
550 public void ChangeServerInfo()
551 {
552 //Get existing values from isolated storage
553 ServerData serverData = new ServerData();
554 Stream stStorage = null;
555 try
556 {
557 IsolatedStorageFile isStore = IsolatedStorageFile.GetUserStoreForAssembly();
558 string sFileName = "mserver0200.dat";
559 stStorage = new IsolatedStorageFileStream(sFileName, FileMode.Open, isStore);
560 IFormatter formatter = new SoapFormatter();
561 serverData = (ServerData) formatter.Deserialize(stStorage);
562 stStorage.Close();
563 }
564 catch (Exception ex)
565 {
566 Debug.Write(ex.Message);
567 if (stStorage != null)
568 stStorage.Close();
569 }
570
571 try
572 {
573 DServerInfo dsi = new DServerInfo();
574 dsi.InitializePage(serverData.m_sAddress,serverData.m_nPort, serverData.m_sNamespace);
575 if (dsi.ShowDialog() != DialogResult.OK)
576 {
577 throw new BMXNetException("User cancelled.");
578 }
579 serverData.m_sAddress = dsi.MServerAddress;
580 serverData.m_nPort = dsi.MServerPort;
581 serverData.m_sNamespace = dsi.MServerNamespace;
582
583 this.m_sServerAddress = dsi.MServerAddress;
584 this.m_nServerPort = dsi.MServerPort;
585 this.m_sServerNamespace = dsi.MServerNamespace;
586
587 //Save port and address to isolated storage
588 try
589 {
590 string sFileName = "mserver0200.dat";
591 IsolatedStorageFile isStore = IsolatedStorageFile.GetUserStoreForAssembly();
592 stStorage = new IsolatedStorageFileStream(sFileName, FileMode.Create, isStore);
593 IFormatter formatter = new SoapFormatter();
594 formatter.Serialize(stStorage, serverData);
595 stStorage.Close();
596 }
597 catch (Exception ex)
598 {
599 Debug.Write(ex.Message);
600 if (stStorage != null)
601 stStorage.Close();
602 }
603
604 }
605 catch (Exception ex)
606 {
607 Debug.Write(ex.Message);
608 if (stStorage != null)
609 stStorage.Close();
610 if (ex.Message == "User cancelled.")
611 {
612 throw ex;
613 }
614 }
615
616 }
617
618 private void GetServerInfo(ref int nPort, ref string sAddress, ref string sNamespace)
619 {
620 //Get values from isolated storage
621 bool bLoaded = false;
622 Stream stStorage = null;
623 try
624 {
625 m_ServerData = new ServerData();
626 IsolatedStorageFile isStore = IsolatedStorageFile.GetUserStoreForAssembly();
627 string sFileName = "mserver0200.dat";
628 stStorage = new IsolatedStorageFileStream(sFileName, FileMode.Open, isStore);
629 IFormatter formatter = new SoapFormatter();
630 m_ServerData = (ServerData) formatter.Deserialize(stStorage);
631 stStorage.Close();
632 sAddress = m_ServerData.m_sAddress;
633 nPort = m_ServerData.m_nPort;
634 sNamespace = m_ServerData.m_sNamespace;
635
636 bLoaded = true;
637 return;
638 }
639 catch (Exception ex)
640 {
641 Debug.Write(ex.Message);
642 if (stStorage != null)
643 stStorage.Close();
644 }
645 try
646 {
647 //If unable to deserialize, display dialog to collect values
648 if (bLoaded == false)
649 {
650 DServerInfo dsi = new DServerInfo();
651 dsi.InitializePage("",10501,"");
652 if (dsi.ShowDialog() != DialogResult.OK)
653 {
654 throw new BMXNetException("Unable to get M Server information");
655 }
656 m_ServerData.m_sAddress = dsi.MServerAddress;
657 m_ServerData.m_nPort = dsi.MServerPort;
658 m_ServerData.m_sNamespace = dsi.MServerNamespace;
659 }
660
661 sAddress = m_ServerData.m_sAddress;
662 nPort = m_ServerData.m_nPort;
663 sNamespace = m_ServerData.m_sNamespace;
664
665 //Save port and address to isolated storage
666 try
667 {
668 string sFileName = "mserver0200.dat";
669 IsolatedStorageFile isStore = IsolatedStorageFile.GetUserStoreForAssembly();
670 stStorage = new IsolatedStorageFileStream(sFileName, FileMode.Create, isStore);
671 IFormatter formatter = new SoapFormatter();
672 formatter.Serialize(stStorage, m_ServerData);
673 stStorage.Close();
674 }
675 catch (Exception ex)
676 {
677 Debug.Write(ex.Message);
678 if (stStorage != null)
679 stStorage.Close();
680 }
681
682 return;
683 }
684 catch (Exception ex)
685 {
686 Debug.Write(ex.Message);
687 if (stStorage != null)
688 stStorage.Close();
689 throw ex;
690 }
691
692 }
693
694 /// <summary>
695 /// Called to connect to an M server
696 /// Server address, port, Access and Verify codes will be
697 /// prompted for depending on whether these values are
698 /// cached.
699 /// </summary>
700 public void LoadConnectInfo()
701 {
702 m_bAutoServer = true;
703 m_bAutoLogin = true;
704 LoadConnectInfo("",0,"","");
705 }
706
707 /// <summary>
708 /// Called to connect to the M server specified by
709 /// server address and listener port. The default namespace on the server will be used.
710 /// Access and Verify codes will be prompted if
711 /// valid values for the current Windows Identity are
712 /// not cached on the server.
713 /// </summary>
714 /// <param name="MServerAddress">The IP address or name of the MServer</param>
715 /// <param name="Port">The port on which the BMXNet Monitor is listening</param>
716 public void LoadConnectInfo(string MServerAddress, int Port)
717 {
718 LoadConnectInfo(MServerAddress, Port, "", "", "");
719 }
720
721 /// <summary>
722 /// Called to connect to the M server specified by
723 /// server address, listener port and namespace.
724 /// Access and Verify codes will be prompted if
725 /// valid values for the current Windows Identity are
726 /// not cached on the server.
727 /// </summary>
728 /// <param name="MServerAddress">The IP address or name of the MServer</param>
729 /// <param name="Port">The port on which the BMXNet Monitor is listening</param>
730 /// <param name="Namespace">The namespace in which the BMXNet application will run</param>
731 public void LoadConnectInfo(string MServerAddress, int Port, string Namespace)
732 {
733 m_bAutoServer = false;
734 m_bAutoLogin = true;
735 LoadConnectInfo(MServerAddress, Port,"","", Namespace);
736 }
737
738 /// <summary>
739 /// Called to connect to an M server
740 /// using specific Access and Verify codes.
741 /// Server address and port will be prompted if they
742 /// are not cached in local storage.
743 /// </summary>
744 /// <param name="AccessCode">The user's access code</param>
745 /// <param name="VerifyCode">The user's verify code</param>
746 public void LoadConnectInfo(string AccessCode, string VerifyCode)
747 {
748 m_bAutoServer = true;
749 m_bAutoLogin = false;
750 LoadConnectInfo("", 0,AccessCode,VerifyCode);
751 }
752
753 /// <summary>
754 /// Called to connect to a specific M server
755 /// using specific Access and Verify codes.
756 /// </summary>
757 /// <param name="AccessCode">The user's access code</param>
758 /// <param name="VerifyCode">The user's verify code</param>
759 /// <param name="MServerAddress">The IP address or name of the MServer</param>
760 /// <param name="Port">The port on which the BMXNet Monitor is listening</param>
761 public void LoadConnectInfo(string MServerAddress, int Port,
762 string AccessCode, string VerifyCode)
763 {
764 LoadConnectInfo(MServerAddress, Port, AccessCode, VerifyCode, "");
765 }
766
767 /// <summary>
768 /// Called to connect to a specific namespace on the M server
769 /// using specific Access and Verify codes.
770 /// </summary>
771 /// <param name="AccessCode">The user's access code</param>
772 /// <param name="VerifyCode">The user's verify code</param>
773 /// <param name="MServerAddress">The IP address or name of the MServer</param>
774 /// <param name="Port">The port on which the BMXNet Monitor is listening</param>
775 /// <param name="Namespace">The namespace in which the BMXNet application will run</param>
776 public void LoadConnectInfo(string MServerAddress, int Port,
777 string AccessCode, string VerifyCode, string Namespace)
778 {
779 //Throws exception if unable to connect to RPMS
780
781 /*
782 * Get RPMS Server Address and Port from local storage.
783 * Prompt for them if they're not there.
784 *
785 * Throw exception if unable to get address/port
786 */
787
788 if (m_bAutoServer == true)
789 {
790 string sAddress = "";
791 int nPort = 0;
792 string sNamespace = "";
793 try
794 {
795 GetServerInfo(ref nPort, ref sAddress, ref sNamespace);
796 m_nServerPort = nPort;
797 m_sServerAddress = sAddress;
798 m_sServerNamespace = sNamespace;
799 }
800 catch (Exception ex)
801 {
802 Debug.Write(ex.Message);
803 throw ex;
804 }
805 }
806 else
807 {
808 m_sServerAddress = MServerAddress;
809 m_nServerPort = Port;
810 m_sServerNamespace = Namespace;
811 }
812
813 /*
814 * Connect to RPMS using current windows identity
815 * Execute BMXNetGetCodes(NTDomain/UserName) to get encrypted AV codes
816 *
817 */
818
819 m_BMXNetLib.CloseConnection();
820 m_BMXNetLib.MServerPort = m_nServerPort;
821 m_BMXNetLib.MServerNamespace = m_sServerNamespace;
822
823 string sLoginError = "";
824 WindowsIdentity winIdentity = WindowsIdentity.GetCurrent();
825 string sIdentName = winIdentity.Name;
826 string sIdentType = winIdentity.AuthenticationType;
827 bool bIdentIsAuth = winIdentity.IsAuthenticated;
828 bool bRet = false;
829 if (m_bAutoLogin == true)
830 {
831 try
832 {
833 //Attempt Auto-login using WindowsIdentity
834
835 if (bIdentIsAuth == false)
836 {
837 throw new BMXNetException("Current Windows User is not authenticated");
838 }
839 bRet = m_BMXNetLib.OpenConnection(m_sServerAddress, winIdentity);
840
841 try
842 {
843 string sDuz = m_BMXNetLib.DUZ;
844 int nDuz = Convert.ToInt16(sDuz);
845 }
846 catch (Exception exCV)
847 {
848 Debug.Write("OpenConnection failed: " + exCV.Message);
849 //Debug.Assert(false);
850 throw new Exception(exCV.Message);
851 }
852 }
853 catch (Exception ex)
854 {
855 Debug.Write(ex.Message);
856 sLoginError = ex.Message;
857 }
858 }
859
860 if (m_BMXNetLib.Connected == false) //BMXNET Login failed or m_bAutoLogin == false
861 {
862 try
863 {
864 //If autologin was attempted and
865 //error message anything other than
866 //"invalid AV code pair"
867 // or "User BMXNET,APPLICATION does not have access to option BMXRPC",
868 // or current windows user is not authenticated or is a guest
869 //then rethrow exception.
870 if ((m_bAutoLogin == true)
871 &&(BMXNetLib.FindSubString(sLoginError, "Not a valid ACCESS CODE/VERIFY CODE pair.") == -1)
872 &&(BMXNetLib.FindSubString(sLoginError, "User BMXNET,APPLICATION does not have access to option BMXRPC") == -1)
873 &&(BMXNetLib.FindSubString(sLoginError, "Not a valid Windows Identity map value.") == -1)
874 &&(BMXNetLib.FindSubString(sLoginError, "Current Windows User is not authenticated") == -1)
875 &&(BMXNetLib.FindSubString(sLoginError, "Windows Integrated Security Not Allowed on this port.") == -1)
876 )
877 {
878 throw new BMXNetException(sLoginError);
879 }
880
881 //Display dialog to collect user-input AV
882
883 DLoginInfo dLog = new DLoginInfo();
884 DialogResult bStop = DialogResult.OK;
885 m_BMXNetLib.CloseConnection();
886 if ((AccessCode == "") && (VerifyCode == ""))
887 {
888 //nothing was passed in, so display a dialog to collect AV codes
889 do
890 {
891 dLog.InitializePage("","");
892 bStop = dLog.ShowDialog();
893 if (bStop == DialogResult.Cancel)
894 {
895 throw new BMXNetException("User cancelled login.");
896 }
897 try
898 {
899 string sTempAccess = dLog.AccessCode;
900 string sTempVerify = dLog.VerifyCode;
901 bRet = m_BMXNetLib.OpenConnection(m_sServerAddress, sTempAccess, sTempVerify);
902 }
903 catch (Exception ex)
904 {
905 Debug.Write(ex.Message);
906 //MessageBox.Show(ex.Message, "RPMS Login Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
907 throw new Exception(ex.Message); ;
908 }
909 }while ((bStop == DialogResult.OK) && (m_BMXNetLib.Connected == false));
910 }
911 else //caller passed in AV codes
912 {
913 try
914 {
915 //Connect using caller's AV
916 bRet = m_BMXNetLib.OpenConnection(m_sServerAddress, AccessCode, VerifyCode);
917 }
918 catch (Exception ex)
919 {
920 Debug.Write(ex.Message);
921 //MessageBox.Show(ex.Message, "RPMS Login Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
922 throw new BMXNetException(ex.Message);
923 }
924 }
925
926 //Map Windows Identity to logged-in RPMS user
927 if ((bIdentIsAuth == true) && (m_BMXNetLib.Connected == true))
928 {
929 m_BMXNetLib.AppContext = "BMXRPC";
930 string sRes = m_BMXNetLib.TransmitRPC("BMXNetSetUser", sIdentName);
931 Debug.Write("LoadConnectInfo BMXNetSetUser returned " + sRes + "\n");
932 }
933 }
934 catch (Exception ex)
935 {
936 Debug.Write(ex.Message);
937 m_BMXNetLib.CloseConnection();
938 throw ex; //this exception will be caught by the caller.
939 }
940 }//End if (m_BMXNetLib.Connected == false)
941
942 try
943 {
944 Debug.Assert(m_BMXNetLib.Connected == true);
945 m_BMXNetLib.AppContext = "BMXRPC";
946 string sRpc = "BMX USER";
947 Debug.Assert(m_BMXNetLib.AppContext == "BMXRPC");
948
949 bool bCtxt = false;
950 int nCtxt = 0;
951 do
952 {
953 try
954 {
955 m_sUserName = m_BMXNetLib.TransmitRPC(sRpc, this.DUZ);
956 bCtxt = true;
957 Debug.Write("BMXNet::LoadConnectInfo succeeded.\n");
958 }
959 catch (Exception ex)
960 {
961 Debug.Write("BMXNet::LoadConnectInfo retrying: " + ex.Message + "\n");
962 m_BMXNetLib.AppContext = "BMXRPC";
963 nCtxt++;
964 if (nCtxt > 4)
965 throw ex;
966 }
967 }while (bCtxt == false);
968
969
970 System.Data.DataTable rsDivisions;
971 rsDivisions = this.GetUserDivisions();
972 m_nDivisionCount = rsDivisions.Rows.Count;
973
974 //The MOST_RECENT_LOOKUP field contains DUZ(2)
975 foreach (System.Data.DataRow r in rsDivisions.Rows)
976 {
977 string sTemp = r["MOST_RECENT_LOOKUP"].ToString();
978 if ((sTemp == "1") || (rsDivisions.Rows.Count == 1))
979 {
980 this.m_sDivision = r["FACILITY_NAME"].ToString();
981 this.m_sDUZ2 = r["FACILITY_IEN"].ToString();
982 break;
983 }
984 }
985 }
986 catch(Exception bmxEx)
987 {
988 m_BMXNetLib.CloseConnection();
989 string sMessage = bmxEx.Message + bmxEx.StackTrace;
990 throw new BMXNetException(sMessage);
991 }
992 return;
993 }
994
995 private DataTable GetUserDivisions()
996 {
997 try
998 {
999 DataTable tb = this.RPMSDataTable("BMXGetFacRS^" + this.DUZ, "DivisionTable");
1000 return tb;
1001 }
1002 catch (Exception bmxEx)
1003 {
1004 string sMessage = bmxEx.Message + bmxEx.StackTrace;
1005 throw new BMXNetException(sMessage);
1006
1007 }
1008 }
1009
1010 public void ChangeDivision(System.Windows.Forms.Form frmCaller)
1011 {
1012 DSelectDivision dsd = new DSelectDivision();
1013 dsd.InitializePage(UserDivisions, DUZ2);
1014
1015 if (dsd.ShowDialog(frmCaller) == DialogResult.Cancel)
1016 return;
1017
1018 if (dsd.DUZ2 != this.DUZ2)
1019 {
1020 DUZ2 = dsd.DUZ2;
1021 }
1022 }
1023
1024 public string GetDSN(string sAppContext)
1025 {
1026 string sDsn = "Data source=";
1027 if (sAppContext == "")
1028 sAppContext = "BMXRPC";
1029
1030 if (m_BMXNetLib.Connected == false)
1031 return sDsn.ToString();
1032
1033 sDsn += this.m_sServerAddress ;
1034 sDsn += ";Location=";
1035 sDsn += this.m_nServerPort.ToString();
1036 sDsn += ";Extended Properties=";
1037 sDsn += sAppContext;
1038
1039 return sDsn;
1040 }
1041
1042
1043 public bool Lock(string sVariable, string sIncrement, string sTimeOut)
1044 {
1045 bool bRet = false;
1046 string sErrorMessage = "";
1047
1048 if (m_BMXNetLib.Connected == false)
1049 {
1050 return bRet;
1051 }
1052 try
1053 {
1054 bRet = this.bmxNetLib.Lock(sVariable, sIncrement, sTimeOut);
1055 return bRet;
1056 }
1057 catch(Exception ex)
1058 {
1059 sErrorMessage = "CGDocumentManager.RPMSDataTable error: " + ex.Message;
1060 throw ex;
1061 }
1062 }
1063
1064 delegate DataTable RPMSDataTableDelegate(string CommandString, string TableName);
1065 delegate DataTable RPMSDataTableDelegate2(string CommandString, string TableName, DataSet dsDataSet);
1066
1067 /// <summary>
1068 /// Creates and names a DataTable using the command in CommandString
1069 /// and the name in TableName.
1070 /// </summary>
1071 /// <param name="CommandString"> The SQL or RPC call</param>
1072 /// <param name="TableName">The name of the resulting table</param>
1073 /// <returns>
1074 /// Returns the resulting DataTable.
1075 /// </returns>
1076 public DataTable RPMSDataTable(string CommandString, string TableName)
1077 {
1078 return this.RPMSDataTable(CommandString, TableName, null);
1079 }
1080
1081 /// <summary>
1082 /// Creates and names a DataTable using the command in CommandString
1083 /// and the name in TableName then adds it to DataSet.
1084 /// </summary>
1085 /// <param name="CommandString">The SQL or RPC call</param>
1086 /// <param name="TableName">The name of the resulting table</param>
1087 /// <param name="dsDataSet">The dataset in which to place the table</param>
1088 /// <returns>
1089 /// Returns the resulting DataTable.
1090 /// </returns>
1091 public DataTable RPMSDataTable(string CommandString, string TableName, DataSet dsDataSet)
1092 {
1093 //Retrieves a recordset from RPMS
1094 //Debug.Assert(this.InvokeRequired == false);
1095 string sErrorMessage = "";
1096 DataTable dtResult = new DataTable(TableName);
1097
1098 if (m_BMXNetLib.Connected == false)
1099 return dtResult;
1100
1101 try
1102 {
1103 BMXNetConnection rpmsConn = new BMXNetConnection(m_BMXNetLib);
1104 BMXNetCommand cmd = (BMXNetCommand) rpmsConn.CreateCommand();
1105 BMXNetDataAdapter da = new BMXNetDataAdapter();
1106
1107 cmd.CommandText = CommandString;
1108 da.SelectCommand = cmd;
1109 if (dsDataSet == null)
1110 {
1111 da.Fill(dtResult);
1112 }
1113 else
1114 {
1115 da.Fill(dsDataSet, TableName);
1116 dtResult = dsDataSet.Tables[TableName];
1117 }
1118 Debug.Write(dtResult.TableName + " DataTable retrieved\n");
1119 return dtResult;
1120 }
1121 catch (Exception ex)
1122 {
1123 sErrorMessage = "CGDocumentManager.RPMSDataTable error: " + ex.Message;
1124 throw ex;
1125 }
1126 }
1127
1128 public int RPMSDataTableAsyncQue(string CommandString, string EventName)
1129 {
1130 try
1131 {
1132 string sCommand = "BMX ASYNC QUEUE^";
1133 //replace ^'s in CommandString with $c(30)'s
1134 char[] cDelim = new char[1];
1135 cDelim[0] = (char) 30;
1136 string sDelim = cDelim[0].ToString();
1137 CommandString = CommandString.Replace("^", sDelim);
1138 sCommand = sCommand + CommandString + "^" + EventName;
1139
1140 DataTable dt = new DataTable();
1141 RPMSDataTableDelegate rdtd = new RPMSDataTableDelegate(RPMSDataTable);
1142 if (this.IsHandleCreated == false)
1143 {
1144 this.CreateHandle();
1145 }
1146
1147 dt = (DataTable) this.Invoke(rdtd, new object[] {sCommand, "Que"});
1148
1149 DataRow dr = dt.Rows[0];
1150 int nErrorID = Convert.ToInt32(dr["ERRORID"]);
1151 int nParam = Convert.ToInt32(dr["PARAM"]);
1152
1153 if (nErrorID == 0)
1154 {
1155 return 0;
1156 }
1157 else
1158 {
1159 return nParam;
1160 }
1161 }
1162 catch (Exception ex)
1163 {
1164 Debug.Write("RPMSDataTableAsyncQue error: " + ex.Message + "\n");
1165 throw ex;
1166 }
1167 }
1168
1169 public DataTable RPMSDataTableAsyncGet(string AsyncInfo, string TableName)
1170 {
1171 return RPMSDataTableAsyncGet(AsyncInfo, TableName, null);
1172 }
1173
1174 public DataTable RPMSDataTableAsyncGet(string AsyncInfo, string TableName, DataSet dsDataSet)
1175 {
1176 try
1177 {
1178 string sCommand = "BMX ASYNC GET^" + AsyncInfo;
1179
1180 DataTable dt;
1181 RPMSDataTableDelegate rdtd = new RPMSDataTableDelegate(RPMSDataTable);
1182 RPMSDataTableDelegate2 rdtd2 = new RPMSDataTableDelegate2(RPMSDataTable);
1183 if (this.IsHandleCreated == false)
1184 {
1185 this.CreateHandle();
1186 }
1187
1188 if (dsDataSet == null)
1189 {
1190 dt = (DataTable) this.Invoke(rdtd, new object[] {sCommand, TableName});
1191 }
1192 else
1193 {
1194 dt = (DataTable) this.Invoke(rdtd2, new object[] {sCommand, TableName, dsDataSet});
1195 }
1196 return dt;
1197 }
1198 catch (Exception ex)
1199 {
1200 Debug.Write("RPMSDataTableAsyncGet error: " + ex.Message + "\n");
1201 throw ex;
1202 }
1203 }
1204
1205 #endregion Methods
1206
1207 }
1208}
Note: See TracBrowser for help on using the repository browser.