Example #1
0
        /// <summary>
        /// Checks if there is currently an active connection
        /// </summary>
        /// <returns></returns>
        private bool IsConnectionEnabled()
        {
            // Start the child process.
            var p = new Process();

            // Redirect the output stream of the child process.
            p.StartInfo.UseShellExecute        = false;
            p.StartInfo.RedirectStandardOutput = true;
            p.StartInfo.FileName  = "rasdial.exe";
            p.StartInfo.Arguments = "";

            p.Start();
            p.WaitForExit(60000);

            //Todo: Analyse output
            var output = p.StandardOutput.ReadToEnd();

            foreach (var aLine in output.Replace("\r", "").Split('\n'))
            {
                if (ConfigName.ToUpper() == aLine.ToUpper().Trim())
                {
                    p.Close();
                    IsConnected = true;
                    return(true);
                }
            }

            p.Close();
            IsConnected = false;
            return(false);
        }
Example #2
0
 public LocalConfiguration(string configName) : base(configName)
 {
     ConfigName      = !ConfigName.EndsWith(".json") ? ConfigName + ".json" : ConfigName;
     _configLocation =
         Path.Combine(
             ConfigBaseLocation.Replace("{0}", _assemblyName)
             .Replace("{1}", _type.Namespace?.Replace(_assemblyName, "").Trim('.')), ConfigName);
 }
        public ArticleConfigDetail(ConfigCode _code, ConfigName _name, ConfigGang _gang,
                                   ConfigType _type, ConfigBind _bind,
                                   TaxingBehaviour _taxing, HealthBehaviour _health, SocialBehaviour _social, params ConfigCode[] _path)
            : base(_code, _gang, _type, _bind, _taxing, _health, _social)
        {
            InternalName = _name;

            InternalPath = _path.ToList();
        }
Example #4
0
        private bool canExecuteSaveNewConfigCommand(object obj)
        {
            if (ConfigName.IsNullOrEmpty() || TempDirPath.IsNullOrEmpty())
            {
                return(false);
            }

            switch (ArchiveType.Value)
            {
            case Zebra.Library.ArchiveType.FTP:
                if (this.FTPCredentials.Server.IsNullOrEmpty() || FTPCredentials.Path.IsNullOrEmpty() || FTPCredentials.Username.IsNullOrEmpty() || FTPCredentials.Password.IsNullOrEmpty() || FTPCredentials.Port.IsNullOrEmpty())
                {
                    return(false);
                }
                break;

            case Zebra.Library.ArchiveType.SFTP:
                return(false);

                break;

            case Zebra.Library.ArchiveType.Local:
                if (LocalArchiveCredentials.Path.IsNullOrEmpty())
                {
                    return(false);
                }
                break;

            default:
                break;
            }

            switch (DBProvider.Value)
            {
            case DatabaseProvider.MySQL:
                if (MySQLCredentials.Server.IsNullOrEmpty() || MySQLCredentials.Port.IsNullOrEmpty() || MySQLCredentials.Username.IsNullOrEmpty() || MySQLCredentials.Password.IsNullOrEmpty() || MySQLCredentials.DatabaseName.IsNullOrEmpty())
                {
                    return(false);
                }
                break;

            case DatabaseProvider.Acces:
                return(false);

                break;

            case DatabaseProvider.SQLite:
                if (SQLiteCredentials.Path.IsNullOrEmpty())
                {
                    return(false);
                }
                break;
            }

            return(true);
        }
        public ArticleConfigMaster(ConfigRole _role, ConfigName _name, ConfigStub _stub, params ConfigRole[] _path)
        {
            InternalRole = _role;

            InternalName = _name;

            InternalPath = _path.ToList();

            InternalStub = CloneUtils <ConfigStub> .CloneOrNull(_stub);
        }
        public void SetSymbolRole(ConfigRole _role, ConfigName _name, ConfigStub _stub, params ConfigRole[] _path)
        {
            InternalRole = _role;

            InternalName = _name;

            InternalPath = _path.ToList();

            InternalStub = CloneUtils <ConfigStub> .CloneOrNull(_stub);
        }
Example #7
0
        string IConfigService.GetValue(ConfigName name)
        {
            var config = _container.Configs.FirstOrDefault(x => x.Key.Equals(name.ToString()));

            if (config != null)
            {
                return(config.Value);
            }
            return(null);
        }
 private void SetConfigurationValue(ConfigName configName, string value)
 {
     if (_overrides.ContainsKey(configName))
     {
         _overrides[configName] = value;
     }
     else
     {
         _overrides.Add(configName, value);
     }
 }
Example #9
0
        public void InitCore()
        {
            LogName = TodayLogPath();
            Lggr    = new TextLogger(LogDirPath, LogName)
                      .Act(x => Err = new IPSErrorMsgData(x));

            Config = XmlTool.ReadXmlClas(
                new IPSDefualtSetting().ToConfig(),                                  // Defulat Setting
                ConfigBasePath.CheckAndCreateDir(),
                ConfigName.CheckAndCreateFile());
        }
        private void SaveConfigurationValue(ConfigName configName, string value)
        {
            Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            KeyValueConfigurationCollection settings = config.AppSettings.Settings;

            settings[configName.ToString()].Value = value;

            Logger.InfoFormat("Saving application configuration - Key: {0}, Value: {1}", configName.ToString(), value);
            config.Save(ConfigurationSaveMode.Modified);

            ConfigurationManager.RefreshSection(config.AppSettings.SectionInformation.Name);
        }
        internal string GetConfigurationValue(ConfigName configName)
        {
            string returnValue = null;

            if (_overrides.ContainsKey(configName))
            {
                returnValue = _overrides[configName];
            }
            else
            {
                returnValue = ConfigurationManager.AppSettings[configName.ToString()];
            }

            if (String.IsNullOrEmpty(returnValue))
            {
                throw new ArgumentNullException(configName.ToString());
            }

            return(returnValue);
        }
Example #12
0
 public static string GetWebConfig(ConfigName configName)
 {
     string strValue = string.Empty;
     try
     {
         WebRequest req = WebRequest.Create(string.Format(@"{0}/Config.ashx?SystemName={1}&ConfigName={2}", GlobalVal.ServicesURL, GlobalVal.SystemNameEN, configName.ToString()));
         WebResponse res = req.GetResponse();
         System.IO.Stream resStream = res.GetResponseStream();
         Encoding encode = System.Text.Encoding.Default;
         StreamReader readStream = new StreamReader(resStream, encode);
         Char[] read = new Char[256];
         int count = readStream.Read(read, 0, 256);
         while (count > 0)
         {
             String str = new String(read, 0, count);
             strValue = strValue + str;
             count = readStream.Read(read, 0, 256);
         }
         resStream.Close();
         readStream.Close();
         res.Close();
         return strValue;
     }
     catch (Exception ex)
     {
         return strValue;
     }
 }
Example #13
0
 public object GetManual(ConfigName ConfigName)
 {
     return(ConfigurationManager.AppSettings[ConfigName.ToString()]);
 }
Example #14
0
 private object GET(ConfigName ConfigName)
 {
     return(ConfigurationManager.AppSettings[ConfigName.ToString()]);
 }
        internal string GetConfigurationValue(ConfigName configName)
        {
            string returnValue = null;
            if (_overrides.ContainsKey(configName))
            {
                returnValue = _overrides[configName];
            }
            else
            {
                returnValue = ConfigurationManager.AppSettings[configName.ToString()];
            }

            if (String.IsNullOrEmpty(returnValue))
            {
                throw new ArgumentNullException(configName.ToString());
            }

            return returnValue;
        }
        internal bool TryGetConfigurationValue(ConfigName configName, out string configValue)
        {
            configValue = _overrides.ContainsKey(configName) ? _overrides[configName] : ConfigurationManager.AppSettings[configName.ToString()];

            return !String.IsNullOrEmpty(configValue);
        }
        private void SaveConfigurationValue(ConfigName configName, string value)
        {
            Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            KeyValueConfigurationCollection settings = config.AppSettings.Settings;

            settings[configName.ToString()].Value = value;

            Logger.InfoFormat("Saving application configuration - Key: {0}, Value: {1}", configName.ToString(), value);
            config.Save(ConfigurationSaveMode.Modified);

            ConfigurationManager.RefreshSection(config.AppSettings.SectionInformation.Name);
        }
 private void SetConfigurationValue(ConfigName configName, string value)
 {
     if (_overrides.ContainsKey(configName))
     {
         _overrides[configName] = value;
     }
     else
     {
         _overrides.Add(configName, value);
     }
 }
        public string FormatFlags()
        {
            ulong copyFlags = PropertyFlags;
            var   output    = string.Empty;

            if (PropertyFlags == 0)
            {
                return(FormatAccess());
            }

            if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.NeedCtorLink) != 0)
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NeedCtorLink;
            }

            if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditorData) != 0)
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditorData;
            }

            if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Net) != 0)
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Net;
            }

            if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.New) != 0)
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.New;
            }

            if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.OnDemand) != 0)
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.OnDemand;
            }

            // Decompiling of this flag is put elsewhere.
            if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Editable) != 0)
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Editable;
            }

            if (HasPropertyFlag(Flags.PropertyFlagsLO.Component))
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Component;
            }

            if (Package.Version > 300 && (PropertyFlags & (ulong)Flags.PropertyFlagsLO.Init) != 0)
            {
                output += "init ";
            }

            /** Flags that are valid as parameters only */
            if (Outer is UFunction && (PropertyFlags & (ulong)Flags.PropertyFlagsLO.Parm) != 0)
            {
                copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Parm;
                // Possible since UE3
                if (Package.Version > 300)
                {
                    if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Const) != 0)
                    {
                        output    += "const ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Const;
                    }
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.CoerceParm) != 0)
                {
                    output    += "coerce ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.CoerceParm;
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.OptionalParm) != 0)
                {
                    output    += "optional ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.OptionalParm;
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.OutParm) != 0)
                {
                    output    += "out ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.OutParm;
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.SkipParm) != 0)
                {
                    output    += "skip ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.SkipParm;
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ReturnParm) != 0)
                {
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ReturnParm;
                }

                // Remove implied flags from GUIComponents
                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ExportObject) != 0)
                {
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ExportObject;
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInline) != 0)
                {
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInline;
                }
            }
            else /** Not a function param. */
            {
                output += FormatAccess();

                // UE3 flags
                if (Package.Version > 129)
                {
                    if (HasPropertyFlag(Flags.PropertyFlagsHO.PrivateWrite))
                    {
                        output    += "privatewrite ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.PrivateWrite << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.ProtectedWrite))
                    {
                        output    += "protectedwrite ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.ProtectedWrite << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.RepNotify))
                    {
                        output    += "repnotify ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.RepNotify << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsLO.NoClear))
                    {
                        output    += "noclear ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NoClear;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsLO.NoImport))
                    {
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NoImport;
                        output    += "noimport ";
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsLO.DataBinding))
                    {
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.DataBinding;
                        output    += "databinding ";
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.EditHide))
                    {
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.EditHide << 32;
                        output    += "edithide ";
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.EditTextBox))
                    {
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.EditTextBox << 32;
                        output    += "edittextbox ";
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.Interp))
                    {
                        output    += "interp ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.Interp << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.NonTransactional))
                    {
                        output    += "nontransactional ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.NonTransactional << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsLO.DuplicateTransient))
                    {
                        output    += "duplicatetransient ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.DuplicateTransient;

                        // Implies: Export, EditInline
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.EditorOnly))
                    {
                        output    += "editoronly ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.EditorOnly << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.CrossLevelPassive))
                    {
                        output    += "crosslevelpassive ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.CrossLevelPassive << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.CrossLevelActive))
                    {
                        output    += "crosslevelactive ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.CrossLevelActive << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.Archetype))
                    {
                        output    += "archetype ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.Archetype << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.NotForConsole))
                    {
                        output    += "notforconsole ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.NotForConsole << 32;
                    }

                    if (HasPropertyFlag(Flags.PropertyFlagsHO.RepRetry))
                    {
                        output    += "repretry ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsHO.RepRetry << 32;
                    }

                    // Instanced is only an alias for Export and EditInline.

                    /*if( HasPropertyFlag( Flags.PropertyFlagsLO.Instanced ) )
                     * {
                     *  output += "instanced ";
                     *  copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Instanced;
                     *
                     *  // Implies: Export, EditInline
                     * }*/

                    if (Package.Version > 500 && HasPropertyFlag(Flags.PropertyFlagsLO.SerializeText))
                    {
                        output    += "serializetext ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.SerializeText;
                    }
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Native) != 0)
                {
                    output    += FormatNative() + " ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Native;
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Const) != 0)
                {
                    output    += "const ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Const;
                }

                if (Package.Version > 500)
                {
                    if (HasPropertyFlag(Flags.PropertyFlagsLO.EditFixedSize))
                    {
                        output    += "editfixedsize ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditFixedSize;
                    }
                }
                else
                {
                    if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditConstArray) != 0)
                    {
                        output    += "editconstarray ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditConstArray;
                    }
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditConst) != 0)
                {
                    output    += "editconst ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditConst;
                }

                // Properties flagged with automated, automatically get those flags added by the compiler.
                if (Package.Version == 128 && (PropertyFlags & (ulong)Flags.PropertyFlagsLO.Automated) != 0)
                {
                    output    += "automated ";
                    copyFlags &= ~((ulong)Flags.PropertyFlagsLO.Automated
                                   | (ulong)Flags.PropertyFlagsLO.EditInlineUse
                                   | (ulong)Flags.PropertyFlagsLO.EditInlineNotify
                                   | (ulong)Flags.PropertyFlagsLO.EditInline
                                   | (ulong)Flags.PropertyFlagsLO.NoExport
                                   | (ulong)Flags.PropertyFlagsLO.ExportObject);
                }
                else // Not Automated
                {
                    if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.NoExport) != 0)
                    {
                        output    += "noexport ";
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NoExport;

                        if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ExportObject) != 0)
                        {
                            copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ExportObject;
                        }
                    }           // avoid outputing export when noexport is flagged as well!
                    else if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ExportObject) != 0)
                    {
                        if (!HasPropertyFlag(Flags.PropertyFlagsLO.DuplicateTransient))
                        {
                            output += "export ";
                        }
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ExportObject;
                    }

                    if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInline) != 0)
                    {
                        if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInlineUse) != 0)
                        {
                            copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInlineUse;
                            output    += "editinlineuse ";
                        }
                        else if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInlineNotify) != 0)
                        {
                            copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInlineNotify;
                            output    += "editinlinenotify ";
                        }
                        else if (!HasPropertyFlag(Flags.PropertyFlagsLO.DuplicateTransient))
                        {
                            output += "editinline ";
                        }
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInline;
                    }
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EdFindable) != 0)
                {
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EdFindable;
                    output    += "edfindable ";
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Deprecated) != 0)
                {
                    output    += "deprecated ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Deprecated;
                }

                // It is important to check for global before checking config! first
                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.GlobalConfig) != 0)
                {
                    output    += "globalconfig ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.GlobalConfig;
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Config;
                }
                else if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Config) != 0)
                {
#if XCOM2
                    if (ConfigName != null && !ConfigName.IsNone())
                    {
                        output += "config(" + ConfigName.ToString() + ") ";
                    }
                    else
                    {
#endif
                    output += "config ";
#if XCOM2
                }
#endif
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Config;
                }

                if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Localized) != 0)
                {
                    output    += "localized ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Localized;
                }

                if (Package.Version == 128)
                {
                    if (HasPropertyFlag(Flags.PropertyFlagsLO.Cache))
                    {
                        copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Cache;
                        output    += "cache ";
                    }
                }

                if (HasPropertyFlag(Flags.PropertyFlagsLO.Transient))
                {
                    output    += "transient ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Transient;
                }

                if (HasPropertyFlag(Flags.PropertyFlagsLO.Travel))
                {
                    output    += "travel ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Travel;
                }

                if (HasPropertyFlag(Flags.PropertyFlagsLO.Input))
                {
                    output    += "input ";
                    copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Input;
                }
            }
            // Local's may never output any of their implied flags!
            if (!IsParm() && Super != null &&
                String.Compare(Super.GetClassName(), "Function", StringComparison.OrdinalIgnoreCase) == 0)
            {
                return(string.Empty);
            }
            // alright...
            //return "/*" + UnrealMethods.FlagToString( PropertyFlags ) + "*/ " + output;
            return(copyFlags != 0 ? "/*" + UnrealMethods.FlagToString(copyFlags) + "*/ " + output : output);
        }
 public DatabaseConfiguration(string moduleId, string configName) : base(configName)
 {
     _moduleId  = moduleId;
     ConfigName = ConfigName.Replace(".json", "");
 }
Example #21
0
 public static string GetString(ConfigName configName)
 {
     return(Get(configName.ToString()));
 }
        internal bool TryGetConfigurationValue(ConfigName configName, out string configValue)
        {
            configValue = _overrides.ContainsKey(configName) ? _overrides[configName] : ConfigurationManager.AppSettings[configName.ToString()];

            return(!String.IsNullOrEmpty(configValue));
        }
Example #23
0
 public static bool GetBool(ConfigName configName)
 {
     return(Get(configName.ToString()).ToBoolean());
 }
Example #24
0
 public static int GetInt32(ConfigName configName)
 {
     return(Get(configName.ToString()).ToInt32());
 }