/[AnywhereTS-MSSQL]/trunk/TSAdminTool/atsDataSet.Designer.cs
ViewVC logotype

Diff of /trunk/TSAdminTool/atsDataSet.Designer.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 60 by william, Thu Jul 12 17:12:08 2012 UTC revision 72 by william, Thu Jul 12 21:23:35 2012 UTC
# Line 10  Line 10 
10    
11  #pragma warning disable 1591  #pragma warning disable 1591
12    
13    using System;
14    using System.Net;
15  namespace AnywhereTS {  namespace AnywhereTS {
16            
17            
# Line 2835  namespace AnywhereTS { Line 2837  namespace AnywhereTS {
2837              [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]              [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
2838              public string ClientName {              public string ClientName {
2839                  get {                  get {
2840                      try {                      try
2841                        {
2842                          return ((string)(this[this.tableClient.ClientNameColumn]));                          return ((string)(this[this.tableClient.ClientNameColumn]));
2843                      }                      }
2844                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2845                          throw new global::System.Data.StrongTypingException("The value for column \'ClientName\' in table \'Client\' is DBNull.", e);                      {
2846                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2847                            {
2848                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientName from table: {1}", this.tableClient.TableName));
2849                            }
2850                            return "";
2851                      }                      }
2852                  }                  }
2853                  set {                  set {
# Line 2863  namespace AnywhereTS { Line 2871  namespace AnywhereTS {
2871                      try {                      try {
2872                          return ((int)(this[this.tableClient.GroupColumn]));                          return ((int)(this[this.tableClient.GroupColumn]));
2873                      }                      }
2874                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2875                          throw new global::System.Data.StrongTypingException("The value for column \'Group\' in table \'Client\' is DBNull.", e);                      {
2876                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2877                            {
2878                                Logging.ATSAdminLog.Error(string.Format("Failed to read Group from table: {1}", this.tableClient.TableName));
2879                            }
2880                            return -1;
2881                      }                      }
2882                  }                  }
2883                  set {                  set {
# Line 2878  namespace AnywhereTS { Line 2891  namespace AnywhereTS {
2891                      try {                      try {
2892                          return ((string)(this[this.tableClient.ScreenResolutionColumn]));                          return ((string)(this[this.tableClient.ScreenResolutionColumn]));
2893                      }                      }
2894                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2895                          throw new global::System.Data.StrongTypingException("The value for column \'ScreenResolution\' in table \'Client\' is DBNull.", e);                      {
2896                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2897                            {
2898                                Logging.ATSAdminLog.Error(string.Format("Failed to read ScreenResolution from table: {1}", this.tableClient.TableName));
2899                            }
2900                            return "";
2901                      }                      }
2902                  }                  }
2903                  set {                  set {
# Line 2893  namespace AnywhereTS { Line 2911  namespace AnywhereTS {
2911                      try {                      try {
2912                          return ((string)(this[this.tableClient.ScreenColorDepthColumn]));                          return ((string)(this[this.tableClient.ScreenColorDepthColumn]));
2913                      }                      }
2914                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2915                          throw new global::System.Data.StrongTypingException("The value for column \'ScreenColorDepth\' in table \'Client\' is DBNull.", e);                      {
2916                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2917                            {
2918                                Logging.ATSAdminLog.Error(string.Format("Failed to read ScreenColorDepth from table: {1}", this.tableClient.TableName));
2919                            }
2920                            return "";
2921                      }                      }
2922                  }                  }
2923                  set {                  set {
# Line 2908  namespace AnywhereTS { Line 2931  namespace AnywhereTS {
2931                      try {                      try {
2932                          return ((bool)(this[this.tableClient.AutoPlayCDColumn]));                          return ((bool)(this[this.tableClient.AutoPlayCDColumn]));
2933                      }                      }
2934                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2935                          throw new global::System.Data.StrongTypingException("The value for column \'AutoPlayCD\' in table \'Client\' is DBNull.", e);                      {
2936                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2937                            {
2938                                Logging.ATSAdminLog.Error(string.Format("Failed to read AutoPlayCD from table: {1}", this.tableClient.TableName));
2939                            }
2940                            return false;
2941                      }                      }
2942                  }                  }
2943                  set {                  set {
# Line 2923  namespace AnywhereTS { Line 2951  namespace AnywhereTS {
2951                      try {                      try {
2952                          return ((string)(this[this.tableClient.ServerNameColumn]));                          return ((string)(this[this.tableClient.ServerNameColumn]));
2953                      }                      }
2954                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2955                          throw new global::System.Data.StrongTypingException("The value for column \'ServerName\' in table \'Client\' is DBNull.", e);                      {
2956                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2957                            {
2958                                Logging.ATSAdminLog.Error(string.Format("Failed to read ServerName from table: {1}", this.tableClient.TableName));
2959                            }
2960                            return "";
2961                      }                      }
2962                  }                  }
2963                  set {                  set {
# Line 2938  namespace AnywhereTS { Line 2971  namespace AnywhereTS {
2971                      try {                      try {
2972                          return ((string)(this[this.tableClient.SessionTypeColumn]));                          return ((string)(this[this.tableClient.SessionTypeColumn]));
2973                      }                      }
2974                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2975                          throw new global::System.Data.StrongTypingException("The value for column \'SessionType\' in table \'Client\' is DBNull.", e);                      {
2976                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2977                            {
2978                                Logging.ATSAdminLog.Error(string.Format("Failed to read SessionType from table: {1}", this.tableClient.TableName));
2979                            }
2980                            return "";
2981                      }                      }
2982                  }                  }
2983                  set {                  set {
# Line 2953  namespace AnywhereTS { Line 2991  namespace AnywhereTS {
2991                      try {                      try {
2992                          return ((bool)(this[this.tableClient.ReconnectPromptColumn]));                          return ((bool)(this[this.tableClient.ReconnectPromptColumn]));
2993                      }                      }
2994                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
2995                          throw new global::System.Data.StrongTypingException("The value for column \'ReconnectPrompt\' in table \'Client\' is DBNull.", e);                      {
2996                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
2997                            {
2998                                Logging.ATSAdminLog.Error(string.Format("Failed to read ReconnectPrompt from table: {1}", this.tableClient.TableName));
2999                            }
3000                            return false;
3001                      }                      }
3002                  }                  }
3003                  set {                  set {
# Line 2968  namespace AnywhereTS { Line 3011  namespace AnywhereTS {
3011                      try {                      try {
3012                          return ((int)(this[this.tableClient.AudioLevelColumn]));                          return ((int)(this[this.tableClient.AudioLevelColumn]));
3013                      }                      }
3014                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3015                          throw new global::System.Data.StrongTypingException("The value for column \'AudioLevel\' in table \'Client\' is DBNull.", e);                      {
3016                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3017                            {
3018                                Logging.ATSAdminLog.Error(string.Format("Failed to read AudioLevel from table: {1}", this.tableClient.TableName));
3019                            }
3020                            return -1;
3021                      }                      }
3022                  }                  }
3023                  set {                  set {
# Line 2983  namespace AnywhereTS { Line 3031  namespace AnywhereTS {
3031                      try {                      try {
3032                          return ((int)(this[this.tableClient.MouseResolutionColumn]));                          return ((int)(this[this.tableClient.MouseResolutionColumn]));
3033                      }                      }
3034                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3035                          throw new global::System.Data.StrongTypingException("The value for column \'MouseResolution\' in table \'Client\' is DBNull.", e);                      {
3036                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3037                            {
3038                                Logging.ATSAdminLog.Error(string.Format("Failed to read MouseResolution from table: {1}", this.tableClient.TableName));
3039                            }
3040                            return -1;
3041                      }                      }
3042                  }                  }
3043                  set {                  set {
# Line 2998  namespace AnywhereTS { Line 3051  namespace AnywhereTS {
3051                      try {                      try {
3052                          return ((string)(this[this.tableClient.CommentColumn]));                          return ((string)(this[this.tableClient.CommentColumn]));
3053                      }                      }
3054                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3055                          throw new global::System.Data.StrongTypingException("The value for column \'Comment\' in table \'Client\' is DBNull.", e);                      {
3056                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3057                            {
3058                                Logging.ATSAdminLog.Error(string.Format("Failed to read Comment from table: {1}", this.tableClient.TableName));
3059                            }
3060                            return "";
3061                      }                      }
3062                  }                  }
3063                  set {                  set {
# Line 3013  namespace AnywhereTS { Line 3071  namespace AnywhereTS {
3071                      try {                      try {
3072                          return ((string)(this[this.tableClient.UsernameColumn]));                          return ((string)(this[this.tableClient.UsernameColumn]));
3073                      }                      }
3074                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3075                          throw new global::System.Data.StrongTypingException("The value for column \'Username\' in table \'Client\' is DBNull.", e);                      {
3076                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3077                            {
3078                                Logging.ATSAdminLog.Error(string.Format("Failed to read Username from table: {1}", this.tableClient.TableName));
3079                            }
3080                            return "";
3081                      }                      }
3082                  }                  }
3083                  set {                  set {
# Line 3028  namespace AnywhereTS { Line 3091  namespace AnywhereTS {
3091                      try {                      try {
3092                          return ((string)(this[this.tableClient.PasswordColumn]));                          return ((string)(this[this.tableClient.PasswordColumn]));
3093                      }                      }
3094                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3095                          throw new global::System.Data.StrongTypingException("The value for column \'Password\' in table \'Client\' is DBNull.", e);                      {
3096                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3097                            {
3098                                Logging.ATSAdminLog.Error(string.Format("Failed to read Password from table: {1}", this.tableClient.TableName));
3099                            }
3100                            return "";
3101                      }                      }
3102                  }                  }
3103                  set {                  set {
# Line 3043  namespace AnywhereTS { Line 3111  namespace AnywhereTS {
3111                      try {                      try {
3112                          return ((string)(this[this.tableClient.ServerDomainColumn]));                          return ((string)(this[this.tableClient.ServerDomainColumn]));
3113                      }                      }
3114                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3115                          throw new global::System.Data.StrongTypingException("The value for column \'ServerDomain\' in table \'Client\' is DBNull.", e);                      {
3116                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3117                            {
3118                                Logging.ATSAdminLog.Error(string.Format("Failed to read ServerDomain from table: {1}", this.tableClient.TableName));
3119                            }
3120                            return "";
3121                      }                      }
3122                  }                  }
3123                  set {                  set {
# Line 3058  namespace AnywhereTS { Line 3131  namespace AnywhereTS {
3131                      try {                      try {
3132                          return ((string)(this[this.tableClient.ServerVersionColumn]));                          return ((string)(this[this.tableClient.ServerVersionColumn]));
3133                      }                      }
3134                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3135                          throw new global::System.Data.StrongTypingException("The value for column \'ServerVersion\' in table \'Client\' is DBNull.", e);                      {
3136                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3137                            {
3138                                Logging.ATSAdminLog.Error(string.Format("Failed to read ServerVersion from table: {1}", this.tableClient.TableName));
3139                            }
3140                            return "";
3141                      }                      }
3142                  }                  }
3143                  set {                  set {
# Line 3073  namespace AnywhereTS { Line 3151  namespace AnywhereTS {
3151                      try {                      try {
3152                          return ((bool)(this[this.tableClient.RedirectFloppyColumn]));                          return ((bool)(this[this.tableClient.RedirectFloppyColumn]));
3153                      }                      }
3154                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3155                          throw new global::System.Data.StrongTypingException("The value for column \'RedirectFloppy\' in table \'Client\' is DBNull.", e);                      {
3156                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3157                            {
3158                                Logging.ATSAdminLog.Error(string.Format("Failed to read RedirectFloppy from table: {1}", this.tableClient.TableName));
3159                            }
3160                            return false;
3161                      }                      }
3162                  }                  }
3163                  set {                  set {
# Line 3088  namespace AnywhereTS { Line 3171  namespace AnywhereTS {
3171                      try {                      try {
3172                          return ((bool)(this[this.tableClient.RedirectCDColumn]));                          return ((bool)(this[this.tableClient.RedirectCDColumn]));
3173                      }                      }
3174                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3175                          throw new global::System.Data.StrongTypingException("The value for column \'RedirectCD\' in table \'Client\' is DBNull.", e);                      {
3176                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3177                            {
3178                                Logging.ATSAdminLog.Error(string.Format("Failed to read RedirectCD from table: {1}", this.tableClient.TableName));
3179                            }
3180                            return false;
3181                      }                      }
3182                  }                  }
3183                  set {                  set {
# Line 3103  namespace AnywhereTS { Line 3191  namespace AnywhereTS {
3191                      try {                      try {
3192                          return ((bool)(this[this.tableClient.RedirectSoundColumn]));                          return ((bool)(this[this.tableClient.RedirectSoundColumn]));
3193                      }                      }
3194                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3195                          throw new global::System.Data.StrongTypingException("The value for column \'RedirectSound\' in table \'Client\' is DBNull.", e);                      {
3196                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3197                            {
3198                                Logging.ATSAdminLog.Error(string.Format("Failed to read RedirectSound from table: {1}", this.tableClient.TableName));
3199                            }
3200                            return false;
3201                      }                      }
3202                  }                  }
3203                  set {                  set {
# Line 3118  namespace AnywhereTS { Line 3211  namespace AnywhereTS {
3211                      try {                      try {
3212                          return ((bool)(this[this.tableClient.DigitalMonitorColumn]));                          return ((bool)(this[this.tableClient.DigitalMonitorColumn]));
3213                      }                      }
3214                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3215                          throw new global::System.Data.StrongTypingException("The value for column \'DigitalMonitor\' in table \'Client\' is DBNull.", e);                      {
3216                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3217                            {
3218                                Logging.ATSAdminLog.Error(string.Format("Failed to read DigitalMonitor from table: {1}", this.tableClient.TableName));
3219                            }
3220                            return false;
3221                      }                      }
3222                  }                  }
3223                  set {                  set {
# Line 3133  namespace AnywhereTS { Line 3231  namespace AnywhereTS {
3231                      try {                      try {
3232                          return ((string)(this[this.tableClient.IcaProtocolColumn]));                          return ((string)(this[this.tableClient.IcaProtocolColumn]));
3233                      }                      }
3234                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3235                          throw new global::System.Data.StrongTypingException("The value for column \'IcaProtocol\' in table \'Client\' is DBNull.", e);                      {
3236                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3237                            {
3238                                Logging.ATSAdminLog.Error(string.Format("Failed to read IcaProtocol from table: {1}", this.tableClient.TableName));
3239                            }
3240                            return "";
3241                      }                      }
3242                  }                  }
3243                  set {                  set {
# Line 3148  namespace AnywhereTS { Line 3251  namespace AnywhereTS {
3251                      try {                      try {
3252                          return ((string)(this[this.tableClient.IcaEncryptionColumn]));                          return ((string)(this[this.tableClient.IcaEncryptionColumn]));
3253                      }                      }
3254                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3255                          throw new global::System.Data.StrongTypingException("The value for column \'IcaEncryption\' in table \'Client\' is DBNull.", e);                      {
3256                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3257                            {
3258                                Logging.ATSAdminLog.Error(string.Format("Failed to read IcaEncryption from table: {1}", this.tableClient.TableName));
3259                            }
3260                            return "";
3261                      }                      }
3262                  }                  }
3263                  set {                  set {
# Line 3163  namespace AnywhereTS { Line 3271  namespace AnywhereTS {
3271                      try {                      try {
3272                          return ((bool)(this[this.tableClient.IcaCompressionColumn]));                          return ((bool)(this[this.tableClient.IcaCompressionColumn]));
3273                      }                      }
3274                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3275                          throw new global::System.Data.StrongTypingException("The value for column \'IcaCompression\' in table \'Client\' is DBNull.", e);                      {
3276                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3277                            {
3278                                Logging.ATSAdminLog.Error(string.Format("Failed to read IcaCompression from table: {1}", this.tableClient.TableName));
3279                            }
3280                            return false;
3281                      }                      }
3282                  }                  }
3283                  set {                  set {
# Line 3178  namespace AnywhereTS { Line 3291  namespace AnywhereTS {
3291                      try {                      try {
3292                          return ((string)(this[this.tableClient.IcaAudioQualityColumn]));                          return ((string)(this[this.tableClient.IcaAudioQualityColumn]));
3293                      }                      }
3294                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3295                          throw new global::System.Data.StrongTypingException("The value for column \'IcaAudioQuality\' in table \'Client\' is DBNull.", e);                      {
3296                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3297                            {
3298                                Logging.ATSAdminLog.Error(string.Format("Failed to read IcaAudioQuality from table: {1}", this.tableClient.TableName));
3299                            }
3300                            return "";
3301                      }                      }
3302                  }                  }
3303                  set {                  set {
# Line 3193  namespace AnywhereTS { Line 3311  namespace AnywhereTS {
3311                      try {                      try {
3312                          return ((bool)(this[this.tableClient.MiscFlippedFixColumn]));                          return ((bool)(this[this.tableClient.MiscFlippedFixColumn]));
3313                      }                      }
3314                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3315                          throw new global::System.Data.StrongTypingException("The value for column \'MiscFlippedFix\' in table \'Client\' is DBNull.", e);                      {
3316                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3317                            {
3318                                Logging.ATSAdminLog.Error(string.Format("Failed to read MiscFlippedFix from table: {1}", this.tableClient.TableName));
3319                            }
3320                            return false;
3321                      }                      }
3322                  }                  }
3323                  set {                  set {
# Line 3208  namespace AnywhereTS { Line 3331  namespace AnywhereTS {
3331                      try {                      try {
3332                          return ((bool)(this[this.tableClient.MiscMousefixColumn]));                          return ((bool)(this[this.tableClient.MiscMousefixColumn]));
3333                      }                      }
3334                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3335                          throw new global::System.Data.StrongTypingException("The value for column \'MiscMousefix\' in table \'Client\' is DBNull.", e);                      {
3336                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3337                            {
3338                                Logging.ATSAdminLog.Error(string.Format("Failed to read MiscMousefix from table: {1}", this.tableClient.TableName));
3339                            }
3340                            return false;
3341                      }                      }
3342                  }                  }
3343                  set {                  set {
# Line 3223  namespace AnywhereTS { Line 3351  namespace AnywhereTS {
3351                      try {                      try {
3352                          return ((bool)(this[this.tableClient.MiscNoAccelerationColumn]));                          return ((bool)(this[this.tableClient.MiscNoAccelerationColumn]));
3353                      }                      }
3354                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3355                          throw new global::System.Data.StrongTypingException("The value for column \'MiscNoAcceleration\' in table \'Client\' is DBNull.", e);                      {
3356                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3357                            {
3358                                Logging.ATSAdminLog.Error(string.Format("Failed to read MiscNoAcceleration from table: {1}", this.tableClient.TableName));
3359                            }
3360                            return false;
3361                      }                      }
3362                  }                  }
3363                  set {                  set {
# Line 3238  namespace AnywhereTS { Line 3371  namespace AnywhereTS {
3371                      try {                      try {
3372                          return ((bool)(this[this.tableClient.DailyRebootColumn]));                          return ((bool)(this[this.tableClient.DailyRebootColumn]));
3373                      }                      }
3374                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3375                          throw new global::System.Data.StrongTypingException("The value for column \'DailyReboot\' in table \'Client\' is DBNull.", e);                      {
3376                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3377                            {
3378                                Logging.ATSAdminLog.Error(string.Format("Failed to read DailyReboot from table: {1}", this.tableClient.TableName));
3379                            }
3380                            return false;
3381                      }                      }
3382                  }                  }
3383                  set {                  set {
# Line 3253  namespace AnywhereTS { Line 3391  namespace AnywhereTS {
3391                      try {                      try {
3392                          return ((string)(this[this.tableClient.KeyboardMapColumn]));                          return ((string)(this[this.tableClient.KeyboardMapColumn]));
3393                      }                      }
3394                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3395                          throw new global::System.Data.StrongTypingException("The value for column \'KeyboardMap\' in table \'Client\' is DBNull.", e);                      {
3396                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3397                            {
3398                                Logging.ATSAdminLog.Error(string.Format("Failed to read KeyboardMap from table: {1}", this.tableClient.TableName));
3399                            }
3400                            return "";
3401                      }                      }
3402                  }                  }
3403                  set {                  set {
# Line 3268  namespace AnywhereTS { Line 3411  namespace AnywhereTS {
3411                      try {                      try {
3412                          return ((string)(this[this.tableClient.TimeZoneColumn]));                          return ((string)(this[this.tableClient.TimeZoneColumn]));
3413                      }                      }
3414                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3415                          throw new global::System.Data.StrongTypingException("The value for column \'TimeZone\' in table \'Client\' is DBNull.", e);                      {
3416                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3417                            {
3418                                Logging.ATSAdminLog.Error(string.Format("Failed to read TimeZone from table: {1}", this.tableClient.TableName));
3419                            }
3420                            return "";
3421                      }                      }
3422                  }                  }
3423                  set {                  set {
# Line 3283  namespace AnywhereTS { Line 3431  namespace AnywhereTS {
3431                      try {                      try {
3432                          return ((bool)(this[this.tableClient.RedirectCom1Column]));                          return ((bool)(this[this.tableClient.RedirectCom1Column]));
3433                      }                      }
3434                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3435                          throw new global::System.Data.StrongTypingException("The value for column \'RedirectCom1\' in table \'Client\' is DBNull.", e);                      {
3436                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3437                            {
3438                                Logging.ATSAdminLog.Error(string.Format("Failed to read RedirectCom1 from table: {1}", this.tableClient.TableName));
3439                            }
3440                            return false;
3441                      }                      }
3442                  }                  }
3443                  set {                  set {
# Line 3298  namespace AnywhereTS { Line 3451  namespace AnywhereTS {
3451                      try {                      try {
3452                          return ((bool)(this[this.tableClient.RedirectCom2Column]));                          return ((bool)(this[this.tableClient.RedirectCom2Column]));
3453                      }                      }
3454                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3455                          throw new global::System.Data.StrongTypingException("The value for column \'RedirectCom2\' in table \'Client\' is DBNull.", e);                      {
3456                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3457                            {
3458                                Logging.ATSAdminLog.Error(string.Format("Failed to read RedirectCom2 from table: {1}", this.tableClient.TableName));
3459                            }
3460                            return false;
3461                      }                      }
3462                  }                  }
3463                  set {                  set {
# Line 3313  namespace AnywhereTS { Line 3471  namespace AnywhereTS {
3471                      try {                      try {
3472                          return ((int)(this[this.tableClient.UsbDriveColumn]));                          return ((int)(this[this.tableClient.UsbDriveColumn]));
3473                      }                      }
3474                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3475                          throw new global::System.Data.StrongTypingException("The value for column \'UsbDrive\' in table \'Client\' is DBNull.", e);                      {
3476                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3477                            {
3478                                Logging.ATSAdminLog.Error(string.Format("Failed to read UsbDrive from table: {1}", this.tableClient.TableName));
3479                            }
3480                            return -1;
3481                      }                      }
3482                  }                  }
3483                  set {                  set {
# Line 3328  namespace AnywhereTS { Line 3491  namespace AnywhereTS {
3491                      try {                      try {
3492                          return ((string)(this[this.tableClient.UsbDriveNameColumn]));                          return ((string)(this[this.tableClient.UsbDriveNameColumn]));
3493                      }                      }
3494                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3495                          throw new global::System.Data.StrongTypingException("The value for column \'UsbDriveName\' in table \'Client\' is DBNull.", e);                      {
3496                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3497                            {
3498                                Logging.ATSAdminLog.Error(string.Format("Failed to read UsbDriveName from table: {1}", this.tableClient.TableName));
3499                            }
3500                            return "";
3501                      }                      }
3502                  }                  }
3503                  set {                  set {
# Line 3343  namespace AnywhereTS { Line 3511  namespace AnywhereTS {
3511                      try {                      try {
3512                          return ((bool)(this[this.tableClient.NumLockColumn]));                          return ((bool)(this[this.tableClient.NumLockColumn]));
3513                      }                      }
3514                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3515                          throw new global::System.Data.StrongTypingException("The value for column \'NumLock\' in table \'Client\' is DBNull.", e);                      {
3516                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3517                            {
3518                                Logging.ATSAdminLog.Error(string.Format("Failed to read NumLock from table: {1}", this.tableClient.TableName));
3519                            }
3520                            return false;
3521                      }                      }
3522                  }                  }
3523                  set {                  set {
# Line 3355  namespace AnywhereTS { Line 3528  namespace AnywhereTS {
3528              [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]              [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
3529              public int ServerPort {              public int ServerPort {
3530                  get {                  get {
3531                      return ((int)(this[this.tableClient.ServerPortColumn]));                      try
3532                        {
3533                            return ((int)(this[this.tableClient.ServerPortColumn]));
3534                        }
3535                        catch (global::System.Exception e)
3536                        {
3537                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3538                            {
3539                                Logging.ATSAdminLog.Error(string.Format("Failed to read ServerPort from table: {1}", this.tableClient.TableName));
3540                            }
3541                            return -1;
3542                        }
3543                  }                  }
3544                  set {                  set {
3545                      this[this.tableClient.ServerPortColumn] = value;                      this[this.tableClient.ServerPortColumn] = value;
# Line 3368  namespace AnywhereTS { Line 3552  namespace AnywhereTS {
3552                      try {                      try {
3553                          return ((global::System.DateTime)(this[this.tableClient.CreatedColumn]));                          return ((global::System.DateTime)(this[this.tableClient.CreatedColumn]));
3554                      }                      }
3555                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3556                          throw new global::System.Data.StrongTypingException("The value for column \'Created\' in table \'Client\' is DBNull.", e);                      {
3557                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3558                            {
3559                                Logging.ATSAdminLog.Error(string.Format("Failed to read Created from table: {1}", this.tableClient.TableName));
3560                            }
3561                            return DateTime.Now;
3562                      }                      }
3563                  }                  }
3564                  set {                  set {
# Line 3383  namespace AnywhereTS { Line 3572  namespace AnywhereTS {
3572                      try {                      try {
3573                          return ((global::System.DateTime)(this[this.tableClient.ModifiedColumn]));                          return ((global::System.DateTime)(this[this.tableClient.ModifiedColumn]));
3574                      }                      }
3575                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3576                          throw new global::System.Data.StrongTypingException("The value for column \'Modified\' in table \'Client\' is DBNull.", e);                      {
3577                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3578                            {
3579                                Logging.ATSAdminLog.Error(string.Format("Failed to read Modified from table: {1}", this.tableClient.TableName));
3580                            }
3581                            return DateTime.Now;
3582                      }                      }
3583                  }                  }
3584                  set {                  set {
# Line 3398  namespace AnywhereTS { Line 3592  namespace AnywhereTS {
3592                      try {                      try {
3593                          return ((string)(this[this.tableClient.IcaApplicationSetColumn]));                          return ((string)(this[this.tableClient.IcaApplicationSetColumn]));
3594                      }                      }
3595                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3596                          throw new global::System.Data.StrongTypingException("The value for column \'IcaApplicationSet\' in table \'Client\' is DBNull.", e);                      {
3597                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3598                            {
3599                                Logging.ATSAdminLog.Error(string.Format("Failed to read IcaApplicationSet from table: {1}", this.tableClient.TableName));
3600                            }
3601                            return "";
3602                      }                      }
3603                  }                  }
3604                  set {                  set {
# Line 3413  namespace AnywhereTS { Line 3612  namespace AnywhereTS {
3612                      try {                      try {
3613                          return ((string)(this[this.tableClient.IcaServerColumn]));                          return ((string)(this[this.tableClient.IcaServerColumn]));
3614                      }                      }
3615                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3616                          throw new global::System.Data.StrongTypingException("The value for column \'IcaServer\' in table \'Client\' is DBNull.", e);                      {
3617                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3618                            {
3619                                Logging.ATSAdminLog.Error(string.Format("Failed to read IcaServer from table: {1}", this.tableClient.TableName));
3620                            }
3621                            return "";
3622                      }                      }
3623                  }                  }
3624                  set {                  set {
# Line 3428  namespace AnywhereTS { Line 3632  namespace AnywhereTS {
3632                      try {                      try {
3633                          return ((string)(this[this.tableClient.TempStringColumn]));                          return ((string)(this[this.tableClient.TempStringColumn]));
3634                      }                      }
3635                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3636                          throw new global::System.Data.StrongTypingException("The value for column \'TempString\' in table \'Client\' is DBNull.", e);                      {
3637                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3638                            {
3639                                Logging.ATSAdminLog.Error(string.Format("Failed to read TempString from table: {1}", this.tableClient.TableName));
3640                            }
3641                            return "";
3642                      }                      }
3643                  }                  }
3644                  set {                  set {
# Line 3443  namespace AnywhereTS { Line 3652  namespace AnywhereTS {
3652                      try {                      try {
3653                          return ((bool)(this[this.tableClient.TempBitColumn]));                          return ((bool)(this[this.tableClient.TempBitColumn]));
3654                      }                      }
3655                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3656                          throw new global::System.Data.StrongTypingException("The value for column \'TempBit\' in table \'Client\' is DBNull.", e);                      {
3657                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3658                            {
3659                                Logging.ATSAdminLog.Error(string.Format("Failed to read TempBit from table: {1}", this.tableClient.TableName));
3660                            }
3661                            return false;
3662                      }                      }
3663                  }                  }
3664                  set {                  set {
# Line 3458  namespace AnywhereTS { Line 3672  namespace AnywhereTS {
3672                      try {                      try {
3673                          return ((int)(this[this.tableClient.TempIntColumn]));                          return ((int)(this[this.tableClient.TempIntColumn]));
3674                      }                      }
3675                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
3676                          throw new global::System.Data.StrongTypingException("The value for column \'TempInt\' in table \'Client\' is DBNull.", e);                      {
3677                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
3678                            {
3679                                Logging.ATSAdminLog.Error(string.Format("Failed to read TempInt from table: {1}", this.tableClient.TableName));
3680                            }
3681                            return -1;
3682                      }                      }
3683                  }                  }
3684                  set {                  set {
# Line 3908  namespace AnywhereTS { Line 4127  namespace AnywhereTS {
4127                      try {                      try {
4128                          return ((int)(this[this.tableGroup.ParentColumn]));                          return ((int)(this[this.tableGroup.ParentColumn]));
4129                      }                      }
4130                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4131                          throw new global::System.Data.StrongTypingException("The value for column \'Parent\' in table \'Group\' is DBNull.", e);                      {
4132                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4133                            {
4134                                Logging.ATSAdminLog.Error(string.Format("Failed to read Parent from table: {1}", this.tableGroup.TableName));
4135                            }
4136                            return -1;
4137                      }                      }
4138                  }                  }
4139                  set {                  set {
# Line 3923  namespace AnywhereTS { Line 4147  namespace AnywhereTS {
4147                      try {                      try {
4148                          return ((string)(this[this.tableGroup.NameColumn]));                          return ((string)(this[this.tableGroup.NameColumn]));
4149                      }                      }
4150                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4151                          throw new global::System.Data.StrongTypingException("The value for column \'Name\' in table \'Group\' is DBNull.", e);                      {
4152                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4153                            {
4154                                Logging.ATSAdminLog.Error(string.Format("Failed to read Name from table: {1}", this.tableGroup.TableName));
4155                            }
4156                            return "";
4157                      }                      }
4158                  }                  }
4159                  set {                  set {
# Line 3973  namespace AnywhereTS { Line 4202  namespace AnywhereTS {
4202                      try {                      try {
4203                          return ((bool)(this[this.tableImage.UseDHCPColumn]));                          return ((bool)(this[this.tableImage.UseDHCPColumn]));
4204                      }                      }
4205                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4206                          throw new global::System.Data.StrongTypingException("The value for column \'UseDHCP\' in table \'Image\' is DBNull.", e);                      {
4207                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4208                            {
4209                                Logging.ATSAdminLog.Error(string.Format("Failed to read UseDHCP from table: {1}", this.tableImage.TableName));
4210                            }
4211                            return true;
4212                      }                      }
4213                  }                  }
4214                  set {                  set {
# Line 3988  namespace AnywhereTS { Line 4222  namespace AnywhereTS {
4222                      try {                      try {
4223                          return ((string)(this[this.tableImage.ClientIPAddressColumn]));                          return ((string)(this[this.tableImage.ClientIPAddressColumn]));
4224                      }                      }
4225                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4226                          throw new global::System.Data.StrongTypingException("The value for column \'ClientIPAddress\' in table \'Image\' is DBNull.", e);                      {
4227                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4228                            {
4229                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientIPAddress from table: {1}", this.tableImage.TableName));
4230                            }
4231                            return IPAddress.None.ToString();
4232                      }                      }
4233                  }                  }
4234                  set {                  set {
# Line 4003  namespace AnywhereTS { Line 4242  namespace AnywhereTS {
4242                      try {                      try {
4243                          return ((string)(this[this.tableImage.ClientIPNetmaskColumn]));                          return ((string)(this[this.tableImage.ClientIPNetmaskColumn]));
4244                      }                      }
4245                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4246                          throw new global::System.Data.StrongTypingException("The value for column \'ClientIPNetmask\' in table \'Image\' is DBNull.", e);                      {
4247                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4248                            {
4249                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientIPNetmask from table: {1}", this.tableImage.TableName));
4250                            }
4251                            return IPAddress.None.ToString();
4252                      }                      }
4253                  }                  }
4254                  set {                  set {
# Line 4018  namespace AnywhereTS { Line 4262  namespace AnywhereTS {
4262                      try {                      try {
4263                          return ((string)(this[this.tableImage.ClientIPGatewayColumn]));                          return ((string)(this[this.tableImage.ClientIPGatewayColumn]));
4264                      }                      }
4265                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4266                          throw new global::System.Data.StrongTypingException("The value for column \'ClientIPGateway\' in table \'Image\' is DBNull.", e);                      {
4267                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4268                            {
4269                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientIPGateway from table: {1}", this.tableImage.TableName));
4270                            }
4271                            return IPAddress.None.ToString();
4272                      }                      }
4273                  }                  }
4274                  set {                  set {
# Line 4033  namespace AnywhereTS { Line 4282  namespace AnywhereTS {
4282                      try {                      try {
4283                          return ((string)(this[this.tableImage.ClientIPDNS1Column]));                          return ((string)(this[this.tableImage.ClientIPDNS1Column]));
4284                      }                      }
4285                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4286                          throw new global::System.Data.StrongTypingException("The value for column \'ClientIPDNS1\' in table \'Image\' is DBNull.", e);                      {
4287                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4288                            {
4289                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientIPDNS1 from table: {1}", this.tableImage.TableName));
4290                            }
4291                            return IPAddress.None.ToString();
4292                      }                      }
4293                  }                  }
4294                  set {                  set {
# Line 4048  namespace AnywhereTS { Line 4302  namespace AnywhereTS {
4302                      try {                      try {
4303                          return ((string)(this[this.tableImage.ClientIPDNS2Column]));                          return ((string)(this[this.tableImage.ClientIPDNS2Column]));
4304                      }                      }
4305                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4306                          throw new global::System.Data.StrongTypingException("The value for column \'ClientIPDNS2\' in table \'Image\' is DBNull.", e);                      {
4307                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4308                            {
4309                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientIPDNS2 from table: {1}", this.tableImage.TableName));
4310                            }
4311                            return IPAddress.None.ToString();
4312                      }                      }
4313                  }                  }
4314                  set {                  set {
# Line 4063  namespace AnywhereTS { Line 4322  namespace AnywhereTS {
4322                      try {                      try {
4323                          return ((string)(this[this.tableImage.ClientIPDNSSuffixColumn]));                          return ((string)(this[this.tableImage.ClientIPDNSSuffixColumn]));
4324                      }                      }
4325                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4326                          throw new global::System.Data.StrongTypingException("The value for column \'ClientIPDNSSuffix\' in table \'Image\' is DBNull.", e);                      {
4327                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4328                            {
4329                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientIPDNSSuffix from table: {1}", this.tableImage.TableName));
4330                            }
4331                            return "";
4332                      }                      }
4333                  }                  }
4334                  set {                  set {
# Line 4078  namespace AnywhereTS { Line 4342  namespace AnywhereTS {
4342                      try {                      try {
4343                          return ((string)(this[this.tableImage.ClientBootServerColumn]));                          return ((string)(this[this.tableImage.ClientBootServerColumn]));
4344                      }                      }
4345                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4346                          throw new global::System.Data.StrongTypingException("The value for column \'ClientBootServer\' in table \'Image\' is DBNull.", e);                      {
4347                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4348                            {
4349                                Logging.ATSAdminLog.Error(string.Format("Failed to read ClientBootServer from table: {1}", this.tableImage.TableName));
4350                            }
4351                            return "";
4352                      }                      }
4353                  }                  }
4354                  set {                  set {
# Line 4093  namespace AnywhereTS { Line 4362  namespace AnywhereTS {
4362                      try {                      try {
4363                          return ((bool)(this[this.tableImage.OnlyUseRDPColumn]));                          return ((bool)(this[this.tableImage.OnlyUseRDPColumn]));
4364                      }                      }
4365                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4366                          throw new global::System.Data.StrongTypingException("The value for column \'OnlyUseRDP\' in table \'Image\' is DBNull.", e);                      {
4367                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4368                            {
4369                                Logging.ATSAdminLog.Error(string.Format("Failed to read OnlyUseRDP from table: {1}", this.tableImage.TableName));
4370                            }
4371                            return false;
4372                      }                      }
4373                  }                  }
4374                  set {                  set {
# Line 4108  namespace AnywhereTS { Line 4382  namespace AnywhereTS {
4382                      try {                      try {
4383                          return ((int)(this[this.tableImage.BootPictureColumn]));                          return ((int)(this[this.tableImage.BootPictureColumn]));
4384                      }                      }
4385                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4386                          throw new global::System.Data.StrongTypingException("The value for column \'BootPicture\' in table \'Image\' is DBNull.", e);                      {
4387                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4388                            {
4389                                Logging.ATSAdminLog.Error(string.Format("Failed to read BootPicture from table: {1}", this.tableImage.TableName));
4390                            }
4391                            return -1;
4392                      }                      }
4393                  }                  }
4394                  set {                  set {
# Line 4123  namespace AnywhereTS { Line 4402  namespace AnywhereTS {
4402                      try {                      try {
4403                          return ((string)(this[this.tableImage.NetworkDriverColumn]));                          return ((string)(this[this.tableImage.NetworkDriverColumn]));
4404                      }                      }
4405                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4406                          throw new global::System.Data.StrongTypingException("The value for column \'NetworkDriver\' in table \'Image\' is DBNull.", e);                      {
4407                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4408                            {
4409                                Logging.ATSAdminLog.Error(string.Format("Failed to read NetworkDriver from table: {1}", this.tableImage.TableName));
4410                            }
4411                            return "";
4412                      }                      }
4413                  }                  }
4414                  set {                  set {
# Line 4138  namespace AnywhereTS { Line 4422  namespace AnywhereTS {
4422                      try {                      try {
4423                          return ((int)(this[this.tableImage.SoundTypeColumn]));                          return ((int)(this[this.tableImage.SoundTypeColumn]));
4424                      }                      }
4425                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4426                          throw new global::System.Data.StrongTypingException("The value for column \'SoundType\' in table \'Image\' is DBNull.", e);                      {
4427                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4428                            {
4429                                Logging.ATSAdminLog.Error(string.Format("Failed to read SoundType from table: {1}", this.tableImage.TableName));
4430                            }
4431                            return -1;
4432                      }                      }
4433                  }                  }
4434                  set {                  set {
# Line 4153  namespace AnywhereTS { Line 4442  namespace AnywhereTS {
4442                      try {                      try {
4443                          return ((string)(this[this.tableImage.SoundDriverColumn]));                          return ((string)(this[this.tableImage.SoundDriverColumn]));
4444                      }                      }
4445                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4446                          throw new global::System.Data.StrongTypingException("The value for column \'SoundDriver\' in table \'Image\' is DBNull.", e);                      {
4447                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4448                            {
4449                                Logging.ATSAdminLog.Error(string.Format("Failed to read SoundDriver from table: {1}", this.tableImage.TableName));
4450                            }
4451                            return "";
4452                      }                      }
4453                  }                  }
4454                  set {                  set {
# Line 4178  namespace AnywhereTS { Line 4472  namespace AnywhereTS {
4472                      try {                      try {
4473                          return ((string)(this[this.tableImage.GraphicsDriverColumn]));                          return ((string)(this[this.tableImage.GraphicsDriverColumn]));
4474                      }                      }
4475                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4476                          throw new global::System.Data.StrongTypingException("The value for column \'GraphicsDriver\' in table \'Image\' is DBNull.", e);                      {
4477                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4478                            {
4479                                Logging.ATSAdminLog.Error(string.Format("Failed to read GraphicsDriver from table: {1}", this.tableImage.TableName));
4480                            }
4481                            return "";
4482                      }                      }
4483                  }                  }
4484                  set {                  set {
# Line 4193  namespace AnywhereTS { Line 4492  namespace AnywhereTS {
4492                      try {                      try {
4493                          return ((bool)(this[this.tableImage.ConfigFileColumn]));                          return ((bool)(this[this.tableImage.ConfigFileColumn]));
4494                      }                      }
4495                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4496                          throw new global::System.Data.StrongTypingException("The value for column \'ConfigFile\' in table \'Image\' is DBNull.", e);                      {
4497                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4498                            {
4499                                Logging.ATSAdminLog.Error(string.Format("Failed to read ConfigFile from table: {1}", this.tableImage.TableName));
4500                            }
4501                            return false;
4502                      }                      }
4503                  }                  }
4504                  set {                  set {
# Line 4208  namespace AnywhereTS { Line 4512  namespace AnywhereTS {
4512                      try {                      try {
4513                          return ((int)(this[this.tableImage.DebugColumn]));                          return ((int)(this[this.tableImage.DebugColumn]));
4514                      }                      }
4515                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4516                          throw new global::System.Data.StrongTypingException("The value for column \'Debug\' in table \'Image\' is DBNull.", e);                      {
4517                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4518                            {
4519                                Logging.ATSAdminLog.Error(string.Format("Failed to read Debug from table: {1}", this.tableImage.TableName));
4520                            }
4521                            return -1;
4522                      }                      }
4523                  }                  }
4524                  set {                  set {
# Line 4223  namespace AnywhereTS { Line 4532  namespace AnywhereTS {
4532                      try {                      try {
4533                          return ((int)(this[this.tableImage.BootPictureWidthColumn]));                          return ((int)(this[this.tableImage.BootPictureWidthColumn]));
4534                      }                      }
4535                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4536                          throw new global::System.Data.StrongTypingException("The value for column \'BootPictureWidth\' in table \'Image\' is DBNull.", e);                      {
4537                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4538                            {
4539                                Logging.ATSAdminLog.Error(string.Format("Failed to read BootPictureWidth from table: {1}", this.tableImage.TableName));
4540                            }
4541                            return -1;
4542                      }                      }
4543                  }                  }
4544                  set {                  set {
# Line 4238  namespace AnywhereTS { Line 4552  namespace AnywhereTS {
4552                      try {                      try {
4553                          return ((int)(this[this.tableImage.BootPictureHeightColumn]));                          return ((int)(this[this.tableImage.BootPictureHeightColumn]));
4554                      }                      }
4555                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4556                          throw new global::System.Data.StrongTypingException("The value for column \'BootPictureHeight\' in table \'Image\' is DBNull.", e);                      {
4557                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4558                            {
4559                                Logging.ATSAdminLog.Error(string.Format("Failed to read BootPictureHeight from table: {1}", this.tableImage.TableName));
4560                            }
4561                            return -1;
4562                      }                      }
4563                  }                  }
4564                  set {                  set {
# Line 4253  namespace AnywhereTS { Line 4572  namespace AnywhereTS {
4572                      try {                      try {
4573                          return ((int)(this[this.tableImage.BootPictureProgressBarColumn]));                          return ((int)(this[this.tableImage.BootPictureProgressBarColumn]));
4574                      }                      }
4575                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4576                          throw new global::System.Data.StrongTypingException("The value for column \'BootPictureProgressBar\' in table \'Image\' is DBNull.", e);                      {
4577                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4578                            {
4579                                Logging.ATSAdminLog.Error(string.Format("Failed to read BootPictureProgressBar from table: {1}", this.tableImage.TableName));
4580                            }
4581                            return -1;
4582                      }                      }
4583                  }                  }
4584                  set {                  set {
# Line 4268  namespace AnywhereTS { Line 4592  namespace AnywhereTS {
4592                      try {                      try {
4593                          return ((byte[])(this[this.tableImage.BootPicturePngColumn]));                          return ((byte[])(this[this.tableImage.BootPicturePngColumn]));
4594                      }                      }
4595                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4596                          throw new global::System.Data.StrongTypingException("The value for column \'BootPicturePng\' in table \'Image\' is DBNull.", e);                      {
4597                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4598                            {
4599                                Logging.ATSAdminLog.Error(string.Format("Failed to read BootPicturePng from table: {1}", this.tableImage.TableName));
4600                            }
4601                            return new byte[0];
4602                      }                      }
4603                  }                  }
4604                  set {                  set {
# Line 4283  namespace AnywhereTS { Line 4612  namespace AnywhereTS {
4612                      try {                      try {
4613                          return ((int)(this[this.tableImage.BootPackageColumn]));                          return ((int)(this[this.tableImage.BootPackageColumn]));
4614                      }                      }
4615                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4616                          throw new global::System.Data.StrongTypingException("The value for column \'BootPackage\' in table \'Image\' is DBNull.", e);                      {
4617                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4618                            {
4619                                Logging.ATSAdminLog.Error(string.Format("Failed to read BootPackage from table: {1}", this.tableImage.TableName));
4620                            }
4621                            return -1;
4622                      }                      }
4623                  }                  }
4624                  set {                  set {
# Line 4558  namespace AnywhereTS { Line 4892  namespace AnywhereTS {
4892                      try {                      try {
4893                          return ((string)(this[this.tableTftpServer.LocalPathColumn]));                          return ((string)(this[this.tableTftpServer.LocalPathColumn]));
4894                      }                      }
4895                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4896                          throw new global::System.Data.StrongTypingException("The value for column \'LocalPath\' in table \'TftpServer\' is DBNull.", e);                      {
4897                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4898                            {
4899                                Logging.ATSAdminLog.Error(string.Format("Failed to read LocalPath from table: {1}", this.tableTftpServer.TableName));
4900                            }
4901                            return "";
4902                      }                      }
4903                  }                  }
4904                  set {                  set {
# Line 4608  namespace AnywhereTS { Line 4947  namespace AnywhereTS {
4947                      try {                      try {
4948                          return ((string)(this[this.tableAppInfo.ValueColumn]));                          return ((string)(this[this.tableAppInfo.ValueColumn]));
4949                      }                      }
4950                      catch (global::System.InvalidCastException e) {                      catch (global::System.Exception e)
4951                          throw new global::System.Data.StrongTypingException("The value for column \'Value\' in table \'AppInfo\' is DBNull.", e);                      {
4952                            using (log4net.NDC.Push(string.Format("Exception: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
4953                            {
4954                                Logging.ATSAdminLog.Error(string.Format("Failed to read Value from table: {1}", this.tableAppInfo.TableName));
4955                            }
4956                            return "";
4957                      }                      }
4958                  }                  }
4959                  set {                  set {
# Line 5374  namespace AnywhereTS.atsDataSetTableAdap Line 5718  namespace AnywhereTS.atsDataSetTableAdap
5718          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
5719          private void InitConnection() {          private void InitConnection() {
5720              this._connection = new global::System.Data.SqlClient.SqlConnection();              this._connection = new global::System.Data.SqlClient.SqlConnection();
5721              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString;              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString.Replace("AnywhereTS", "master");
5722          }          }
5723                    
5724          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
# Line 5686  SELECT ID, Parent, Name FROM [Group] WHE Line 6030  SELECT ID, Parent, Name FROM [Group] WHE
6030          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
6031          private void InitConnection() {          private void InitConnection() {
6032              this._connection = new global::System.Data.SqlClient.SqlConnection();              this._connection = new global::System.Data.SqlClient.SqlConnection();
6033              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString;              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString.Replace("AnywhereTS", "master");
6034          }          }
6035                    
6036          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
# Line 6195  SELECT UseDHCP, ClientIPAddress, ClientI Line 6539  SELECT UseDHCP, ClientIPAddress, ClientI
6539          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
6540          private void InitConnection() {          private void InitConnection() {
6541              this._connection = new global::System.Data.SqlClient.SqlConnection();              this._connection = new global::System.Data.SqlClient.SqlConnection();
6542              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString;              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString.Replace("AnywhereTS", "master");
6543          }          }
6544                    
6545          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
# Line 7159  SELECT UseDHCP, ClientIPAddress, ClientI Line 7503  SELECT UseDHCP, ClientIPAddress, ClientI
7503          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
7504          private void InitConnection() {          private void InitConnection() {
7505              this._connection = new global::System.Data.SqlClient.SqlConnection();              this._connection = new global::System.Data.SqlClient.SqlConnection();
7506              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString;              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString.Replace("AnywhereTS", "master");
7507          }          }
7508                    
7509          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
# Line 7431  SELECT Path, LocalPath FROM TftpServer W Line 7775  SELECT Path, LocalPath FROM TftpServer W
7775          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
7776          private void InitConnection() {          private void InitConnection() {
7777              this._connection = new global::System.Data.SqlClient.SqlConnection();              this._connection = new global::System.Data.SqlClient.SqlConnection();
7778              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString;              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString.Replace("AnywhereTS", "master");
7779          }          }
7780                    
7781          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
# Line 7733  SELECT Path, LocalPath FROM TftpServer W Line 8077  SELECT Path, LocalPath FROM TftpServer W
8077          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
8078          private void InitConnection() {          private void InitConnection() {
8079              this._connection = new global::System.Data.SqlClient.SqlConnection();              this._connection = new global::System.Data.SqlClient.SqlConnection();
8080              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString;              this._connection.ConnectionString = global::AnywhereTS.Properties.Settings.Default.atsConnectionString.Replace("AnywhereTS", "master");
8081          }          }
8082                    
8083          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]          [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

Legend:
Removed from v.60  
changed lines
  Added in v.72

  ViewVC Help
Powered by ViewVC 1.1.22