Exemplo n.º 1
0
        /// <summary>
        /// 使用一个XML文件的名字生成实例
        /// </summary>
        /// <param name="filePathName"></param>
        /// <param name="type"></param>
        public CustomConfigBase(string filePathName, ConfigType type)
        {
            this.filePathName = filePathName;
            this.m_ConfigType = type;

            this.OpenConfigFile(type);
        }
        public ColorPropertyData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.variableName = new StringData(configType, prefix + name, "VariableName", "Color variable name", "", "waferBackground");
            AddChild(this.variableName);

            this.propertyName = new StringData(configType, prefix + name, "Name", "Color name", "", "Wafer background");
            AddChild(this.propertyName);

            this.fontName = new StringData(configType, prefix + name, "FontName", "Font name", "", "Microsoft Sans Serif");
            AddChild(this.fontName);

            this.fontSize = new IntegerData(configType, prefix + name, "FontSize", "Font size", "", 8);
            AddChild(this.fontSize);

            this.fontBold = new BooleanData(configType, prefix + name, "FontBold", "Font bold", "", false);
            AddChild(this.fontBold);

            this.foreground = new StringData(configType, prefix + name, "Foreground", "Foreground color", "", "White");
            AddChild(this.foreground);

            this.background = new StringData(configType, prefix + name, "Background", "Background color", "", "White");
            AddChild(this.background);

            NewFont();
            NewForeColor();
            NewBackColor();
        }
Exemplo n.º 3
0
        /// <summary>
        /// 使用一个可执行文件(.exe或.dll)生成实例
        /// </summary>
        /// <param name="assembly"></param>
        public CustomConfigBase(System.Reflection.Assembly assembly)
        {
            this.filePathName = assembly.Location + ".config";

            this.m_ConfigType = ConfigType.Exe;

            this.OpenConfigFile(this.m_ConfigType);
        }
Exemplo n.º 4
0
        public CultureData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.cultureName = new StringData(configType, prefix + name, "Name", "Culture name", "", "English");
            AddChild(this.cultureName);

            this.cultureCode = new StringData(configType, prefix + name, "Name", "Culture code", "", "en-US");
            AddChild(this.cultureCode);
        }
        public LaserscribeFormatData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.enabled = new BooleanData(configType, prefix + name, "Enabled", "Enabled", "", false);
            AddChild(this.enabled);

            this.mask = new StringData(configType, prefix + name, "Mask", "Mask", "", "");
            AddChild(this.mask);
        }
Exemplo n.º 6
0
 /// <summary>
 /// Create a new config object
 /// </summary>
 /// <param name="p">The plugin that is using the config object</param>
 /// <param name="c">The config type you want</param>
 /// <param name="filename">The file name (DONT INCLUDE EXTENTION)</param>
 public Config(Plugin p, ConfigType c, string filename)
 {
     this.filename = filename;
     if (!Directory.Exists("plugins/" + p.name)) Directory.CreateDirectory("plugins/" + p.name);
     if (!File.Exists("plugins/" + p.name + "/" + filename + ".config") && c == ConfigType.Setting) File.Create("plugins/" + p.name + "/" + filename + ".config");
     if (!File.Exists("plugins/" + p.name + "/" + filename + ".file") && c == ConfigType.SaveFile) File.Create("plugins/" + p.name + "/" + filename + ".file");
     this.p = p;
     this.c = c;
 }
        public LaserscribeLotFilterData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.mask = new StringData(configType, prefix + name, "Mask", "Lot ID mask", "", "");
            AddChild(this.mask);

            this.checksum = new BooleanData(configType, prefix + name, "Checksum", "Laserscribe has semi checksum", "", false);
            AddChild(this.checksum);
        }
Exemplo n.º 8
0
        protected ValueData(ConfigType configType, string prefix, string name, string description, string editor, object defaultValue)
            : base(configType, prefix, name, description, editor)
        {
            this.defaultValue =
            this.currentValue = defaultValue;

            changed =
            wasRead =
            hasValue = false;
        }
Exemplo n.º 9
0
 public IConfig CreateConfig(string file, ConfigType type)
 {
     switch (type)
     {
         case ConfigType.XML:
             return new XMLConfig(file);
         case ConfigType.Json:
             return new JsonConfig(file);
     }
     return null;
 }
Exemplo n.º 10
0
 public BinListData(ConfigType configType, string prefix, string name, string description, string editor, List<int> defaultValue)
     : base(configType, prefix, name, description, editor, null)
 {
     this.currentValue = new List<int>();
     this.defaultValue = new List<int>();
     if ((defaultValue != null) && (defaultValue.Count > 0))
     {
         (this.currentValue as List<int>).AddRange(defaultValue);
         (this.defaultValue as List<int>).AddRange(defaultValue);
     }
 }
Exemplo n.º 11
0
        public GuiConfigData(ConfigType configType, string configVersion, XmlDocument templateDoc, int levelCount)
        {
            this.configType = configType;
            this.configVersion = configVersion;
            this.templateDoc = templateDoc;
            this.levelCount = levelCount;

            childList = new List<BaseData>[levelCount];
            for (int idx = 0; idx < levelCount; idx++)
                childList[idx] = new List<BaseData>();
            CreateChildList();
        }
Exemplo n.º 12
0
        protected BaseData(ConfigType configType, string prefix, string name, string description, string editor)
        {
            this.configType = configType;

            this.prefix = prefix;
            this.name = name;

            this.description = description;
            this.editor = editor;

            this.fireEvent = 0;
            this.dataChangedDelegate = null;
        }
Exemplo n.º 13
0
 private void BindConfigType()
 {
     DataSet list = new ConfigType().GetList("");
     this.dropConfigType.DataSource = list;
     this.dropConfigType.DataTextField = "TypeName";
     this.dropConfigType.DataValueField = "KeyType";
     this.dropConfigType.DataBind();
     this.dropConfigTypeSearch.DataSource = list;
     this.dropConfigTypeSearch.DataTextField = "TypeName";
     this.dropConfigTypeSearch.DataValueField = "KeyType";
     this.dropConfigTypeSearch.DataBind();
     this.dropConfigTypeSearch.Items.Insert(0, Site.PleaseSelect);
 }
Exemplo n.º 14
0
        public string GetConfigSchema(ConfigType configType)
        {
            if ( configType == ConfigType.TransmitLocation ) {
            string resName = NS + "." + "SendPortSchema.xsd";

            Assembly asm = Assembly.GetExecutingAssembly();
            Stream stream = asm.GetManifestResourceStream(resName);
            using ( StreamReader reader = new StreamReader(stream) ) {
               return reader.ReadToEnd();
            }
             }
             return null;
        }
Exemplo n.º 15
0
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="configType"></param>
 public ConfigurationOperator(ConfigType configType)
 {
     this.configType = configType;
     if (configType == ConfigType.ExeConfig)
     {
         configPath = Application.ExecutablePath; ;
     }
     else
     {
         configPath = HttpContext.Current.Request.ApplicationPath;
     }
     Initialize();
 }
Exemplo n.º 16
0
        public Server(ConfigType configType)
        {
            ConfigType = configType;

            Modules.Add(new ModuleSCON(this));
            Modules.Add(new ModuleNPC(this));
            Modules.Add(new ModuleP3D(this));
            Modules.Add(new ModulePokeD(this));

            Modules.AddRange(LoadModules());

            CommandManager = new CommandManager(this);
            ChatChannelManager = new ChatChannelManager(this);
        }
Exemplo n.º 17
0
        public BinData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.value = new IntegerData(configType, prefix + name, "Value", "Value", "", 0);
            AddChild(this.value);

            this.good = new BooleanData(configType, prefix + name, "Good", "Die is good", "", false);
            AddChild(this.good);

            this.reprobable = new BooleanData(configType, prefix + name, "Reprobed", "Die is reprobable", "", false);
            AddChild(this.reprobable);

            this.inkable = new BooleanData(configType, prefix + name, "Inked", "Die is inkable", "", false);
            AddChild(this.inkable);

            NewBin();
        }
Exemplo n.º 18
0
        public PassData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.id = new StringData(configType, prefix + name, "Id", "ID", "", "");
            AddChild(this.id);

            this.previousStr = new StringData(configType, prefix + name, "PreviousList", "Pass's previous bin value list", "", "");
            AddChild(this.previousStr);

            this.actualStr = new StringData(configType, prefix + name, "ActualList", "Pass's actual bin value list", "", "");
            AddChild(this.actualStr);

            previousList = new List<int>();
            actualList = new List<int>();

            NewList();
        }
        public string GetConfigSchema(ConfigType type)
        {
            switch (type)
            {
                case ConfigType.ReceiveHandler:
                case ConfigType.ReceiveLocation:

                    string receiveConfig = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
                                    + "<xs:schema targetNamespace=\"http://microservicebus.biztalk\""
                                    + "           elementFormDefault=\"qualified\""
                                    + "           xmlns=\"http://microservicebus.biztalk\""
                                    + "           xmlns:mstns=\"http://tempuri.org/XMLSchema.xsd\""
                                    + "           xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
                                    + "    <xs:element name=\"CustomProps\">"
                                    + "        <xs:complexType>"
                                    + "            <xs:sequence>"
                                    + "                <xs:element name=\"uri\" type=\"xs:string\" />"
                                    + "            </xs:sequence>"
                                    + "        </xs:complexType>"
                                    + "    </xs:element>"
                                    + "</xs:schema>";
                    return receiveConfig;
                case ConfigType.TransmitHandler:
                case ConfigType.TransmitLocation:
                    string transmitConfig = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
                                    + "<xs:schema targetNamespace=\"http://microservicebus.biztalk\""
                                    + "           elementFormDefault=\"qualified\""
                                    + "           xmlns=\"http://microservicebus.biztalk\""
                                    + "           xmlns:mstns=\"http://tempuri.org/XMLSchema.xsd\""
                                    + "           xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
                                    + "    <xs:element name=\"CustomProps\">"
                                    + "        <xs:complexType>"
                                    + "            <xs:sequence>"
                                    + "                <xs:element name=\"uri\" type=\"xs:string\" />"
                                    + "                <xs:element name=\"address\" type=\"xs:string\" />"
                                    + "                <xs:element name=\"port\" type=\"xs:integer\" />"
                                    + "                <xs:element name=\"contentType\" type=\"xs:string\" />"
                                    + "            </xs:sequence>"
                                    + "        </xs:complexType>"
                                    + "    </xs:element>"
                                    + "</xs:schema>";
                    return transmitConfig;
                default:
                    return null;
            }
        }
        public ConsecutiveFailCustomRuleData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.enabled = new BooleanData(configType, prefix + name, "Enabled", "Enabled", "", false);
            AddChild(enabled);

            this.threshold = new IntegerData(configType, prefix + name, "Threshold", "Threshold", "", 0);
            AddChild(threshold);

            this.message = new StringData(configType, prefix + name, "Message", "Message", "", "");
            AddChild(message);

            this.binListStr = new StringData(configType, prefix + name, "BinList", "Bin list", "", "");
            AddChild(binListStr);

            binList = new List<int>();
            GetBinList(binListStr.Value);
        }
Exemplo n.º 21
0
        public CustomScriptData(ConfigType configType, string prefix, string name, string description, string editor)
            : base(configType, prefix, name, description, editor)
        {
            this.scriptName = new StringData(configType, prefix + name, "Name", "Script name", "", "");
            AddChild(this.scriptName);

            this.enabled = new BooleanData(configType, prefix + name, "Enabled", "Enabled", "", false);
            AddChild(this.enabled);

            this.command = new StringData(configType, prefix + name, "Command", "Command", "", "");
            AddChild(this.command);

            this.waitToComplete = new BooleanData(configType, prefix + name, "WaitToComplete", "Wait to complete", "", false);
            AddChild(this.waitToComplete);

            this.openInConsole = new BooleanData(configType, prefix + name, "OpenInConsole", "Open in console", "", false);
            AddChild(this.openInConsole);

            NewScript();
        }
        public string GetConfigSchema(ConfigType type)
        {
            string result = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
                            + "<xs:schema targetNamespace=\"http://microservicebus.biztalk\""
                            + "           elementFormDefault=\"qualified\""
                            + "           xmlns=\"http://microservicebus.biztalk\""
                            + "           xmlns:mstns=\"http://tempuri.org/XMLSchema.xsd\""
                            + "           xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
                            + "    <xs:element name=\"CustomProps\">"
                            + "        <xs:complexType>"
                            + "            <xs:sequence>"
                            + "                <xs:element name=\"uri\" type=\"xs:string\" />"
                            + "            </xs:sequence>"
                            + "        </xs:complexType>"
                            + "    </xs:element>"
                            + "</xs:schema>";

            if (type == 0) return result;

            return null;
        }
Exemplo n.º 23
0
        /// <summary>
        /// Validate the configuration of the send port.
        /// </summary>
        /// <param name="configType">Configuration Type</param>
        /// <param name="configuration">Configuration XML</param>
        /// <returns>The new Configuration XML</returns>
        /// <remarks>
        /// In here we load the configuration and create a new URI for
        /// the send port based on the value of the name
        /// attribute introduced by the user.
        /// </remarks>
        public string ValidateConfiguration(ConfigType configType, string configuration)
        {
            if ( configType != ConfigType.TransmitLocation )
            return configuration;

             XmlDocument doc = new XmlDocument();
             doc.LoadXml(configuration);

             XmlNode uriNode = doc.SelectSingleNode("CustomProps/uri");
             if ( uriNode == null ) {
            uriNode = doc.CreateElement("uri");
            doc.DocumentElement.AppendChild(uriNode);
             }

             XmlNode nameNode = doc.SelectSingleNode("CustomProps/name");
             if ( nameNode == null || nameNode.InnerText.Trim().Length == 0 ) {
            throw new InvalidOperationException("Name cannot be blank");
             }
             uriNode.InnerText = "null://" + nameNode.InnerText.Trim();

             return doc.OuterXml;
        }
 public DatabaseComponentConfigFile(ConfigType configType) : base(new ConfigFolder().CreateFile($"Database{configType.GetFileExtension()}", CreationCollisionOption.OpenIfExists)) => ConfigType = configType;
Exemplo n.º 25
0
 public object GetTypedConfigValue(ConfigType ct, System.Type type) =>
 GetValueFromConfig(this.GetConfigValue(ct), type);
 internal string GetConfigPath(Games game, ConfigType type)
 {
     switch((int)type) {
         case 0:
             if(game == Games.CS) {
                 return Path.Combine(this.CsPath, "autoexec.cfg");
             }else if(game == Games.CSS) {
                 return Path.Combine(this.CssPath, "autoexec.cfg");
             }else {
                 return Path.Combine(this.CzPath, "autoexec.cfg");
             }
         case 1:
             if(game == Games.CS) {
                 return Path.Combine(this.CsPath, "config.cfg");
             }else if(game == Games.CSS) {
                 return Path.Combine(this.CssPath, "config.cfg");
             }else {
                 return Path.Combine(this.CzPath, "config.cfg");
             }
         case 2:
             if(game == Games.CS) {
                 return Path.Combine(this.CsPath, "czbind.cfg");
             }else if(game == Games.CSS) {
                 return Path.Combine(this.CssPath, "czbind.cfg");
             }else {
                 return Path.Combine(this.CzPath, "czbind.cfg");
             }
         case 3:
             if(game == Games.CS) {
                 return Path.Combine(this.CsPath, "userconfig.cfg");
             }else if(game == Games.CSS) {
                 return Path.Combine(this.CssPath, "userconfig.cfg");
             }else {
                 return Path.Combine(this.CzPath, "userconfig.cfg");
             }
         case 4:
             if(game == Games.CSS) {
                 return Path.Combine(this.CssPath, "compatibility.cfg");
             }
             break;
         case 5:
             if(game == Games.CS) {
                 return Path.Combine(this.CsPath, "clips.cfg");
             }else if(game == Games.CSS) {
                 return Path.Combine(this.CssPath, "clips.cfg");
             }else {
                 return Path.Combine(this.CzPath, "clips.cfg");
             }
     }
     return "";
 }
Exemplo n.º 27
0
 public ConfigType SaveConfigType(ConfigType data)
 {
     try {
     SetService();  return SerClient.SaveConfigType(data); }
     finally
     {
         SerClient.Close();
         if (SerClient.State == CommunicationState.Faulted)
         SerClient.Abort(); 
     }
 }
Exemplo n.º 28
0
        // 根据生成的类,动态编译把json转成protobuf
        private static void ExportExcelProtobuf(ConfigType configType)
        {
            string classPath = GetClassDir(configType);
            List<SyntaxTree> syntaxTrees = new List<SyntaxTree>();
            List<string> protoNames = new List<string>();
            foreach (string classFile in Directory.GetFiles(classPath, "*.cs"))
            {
                protoNames.Add(Path.GetFileNameWithoutExtension(classFile));
                syntaxTrees.Add(CSharpSyntaxTree.ParseText(File.ReadAllText(classFile)));
            }
            
            List<PortableExecutableReference> references = new List<PortableExecutableReference>();
            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
            foreach (Assembly assembly in assemblies)
            {
                try
                {
                    if (assembly.IsDynamic)
                    {
                        continue;
                    }

                    if (assembly.Location == "")
                    {
                        continue;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    throw;
                }

                PortableExecutableReference reference = MetadataReference.CreateFromFile(assembly.Location);
                references.Add(reference);
            }

            CSharpCompilation compilation = CSharpCompilation.Create(
                null, 
                syntaxTrees.ToArray(), 
                references.ToArray(), 
                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));

            using MemoryStream memSteam = new MemoryStream();
            
            EmitResult emitResult = compilation.Emit(memSteam);
            if (!emitResult.Success)
            {
                StringBuilder stringBuilder = new StringBuilder();
                foreach (Diagnostic t in emitResult.Diagnostics)
                {
                    stringBuilder.AppendLine(t.GetMessage());
                }
                throw new Exception($"动态编译失败:\n{stringBuilder}");
            }
            
            memSteam.Seek(0, SeekOrigin.Begin);

            Assembly ass = Assembly.Load(memSteam.ToArray());

            string dir = GetProtoDir(configType);
            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }
            
            foreach (string protoName in protoNames)
            {
                Type type = ass.GetType($"ET.{protoName}Category");
                Type subType = ass.GetType($"ET.{protoName}");
                Serializer.NonGeneric.PrepareSerializer(type);
                Serializer.NonGeneric.PrepareSerializer(subType);
                
                
                string json = File.ReadAllText(Path.Combine(string.Format(jsonDir, configType), $"{protoName}.txt"));
                object deserialize = BsonSerializer.Deserialize(json, type);

                string path = Path.Combine(dir, $"{protoName}Category.bytes");

                using FileStream file = File.Create(path);
                Serializer.Serialize(file, deserialize);
            }
        }
Exemplo n.º 29
0
 public static bool HasDarklandsPath(ConfigType type)
 {
     return(HasSetting(
                type, SettingDarklandsPath));
 }
Exemplo n.º 30
0
            /// <summary>
            /// Writes an Object to a Configuration Node, using it's parser targets
            /// </summary>
            /// <returns></returns>
            public static ConfigNode WriteObjectToConfigNode <T>(string name, ref ConfigNode node, T target)
            {
                // Start
                ConfigNode config = node.AddNode(name);

                // Crawl it's member infos
                foreach (MemberInfo member in target.GetType().GetMembers(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
                {
                    // Get the first parser target
                    ParserTarget[] targets = member.GetCustomAttributes(typeof(ParserTarget), false) as ParserTarget[];
                    if (targets.Length == 0)
                    {
                        continue;
                    }

                    // Is this a node or a value?
                    RequireConfigType[] configTypes = (member.MemberType == MemberTypes.Field ? (member as FieldInfo).FieldType : (member as PropertyInfo).PropertyType).GetCustomAttributes(typeof(RequireConfigType), false) as RequireConfigType[];

                    // Write
                    System.Object memberValue = member.GetValue(target);
                    Type          memberType  = member.GetMemberType();

                    if (memberValue == null)
                    {
                        continue;
                    }

                    // Type
                    ConfigType configType = configTypes.Length == 1 ? configTypes[0].Type : memberType.Name.StartsWith("MapSOParser_") || memberType == typeof(string) ? ConfigType.Value : ConfigType.Node;

                    // Convert
                    if (memberType != typeof(string) && (configType == ConfigType.Value || memberType == typeof(FloatCurveParser)))
                    {
                        memberValue = memberType == typeof(PhysicsMaterialParser) ?
                                      memberType.GetProperty("Value").GetValue(memberValue, null) :
                                      memberType == typeof(FloatCurveParser) ?
                                      memberType.GetProperty("Value").GetValue(memberValue, null) :
                                      memberType.GetProperty("Value").GetValue(memberValue);
                        if (memberValue == null || memberType == typeof(StockMaterialParser))
                        {
                            continue;
                        }
                        if (memberValue.GetType().GetInterface("IEnumerable") != null && memberType != typeof(string))
                        {
                            memberValue = String.Join(memberType == typeof(StringCollectionParser) ? "," : " ", (memberValue as IEnumerable).Cast <System.Object>().Select(o => o.ToString()).ToArray());
                        }
                    }

                    // Format Unity types
                    if (writeableTypes.Contains(memberType))
                    {
                        if (memberValue is Vector2)
                        {
                            memberValue = ConfigNode.WriteVector((Vector2)memberValue);
                        }
                        if (memberValue is Vector3)
                        {
                            memberValue = ConfigNode.WriteVector((Vector3)memberValue);
                        }
                        if (memberValue is Vector3d)
                        {
                            memberValue = ConfigNode.WriteVector((Vector3d)memberValue);
                        }
                        if (memberValue is Vector4)
                        {
                            memberValue = ConfigNode.WriteVector((Vector4)memberValue);
                        }
                        if (memberValue is Quaternion)
                        {
                            memberValue = ConfigNode.WriteQuaternion((Quaternion)memberValue);
                        }
                        if (memberValue is QuaternionD)
                        {
                            memberValue = ConfigNode.WriteQuaternion((QuaternionD)memberValue);
                        }
                        if (memberValue is Color)
                        {
                            memberValue = ConfigNode.WriteColor((Color)memberValue);
                        }
                    }

                    // Texture
                    Type[] textureTypes = { typeof(Mesh), typeof(Texture2D), typeof(Texture), typeof(MapSO), typeof(CBAttributeMapSO) };
                    if (textureTypes.Contains(memberValue.GetType()) || textureTypes.Contains(memberValue.GetType().BaseType))
                    {
                        memberValue = Format(memberValue as Object);
                    }

                    // Write
                    if (configType == ConfigType.Value && memberValue.GetType() != typeof(FloatCurve) && memberValue.GetType() != typeof(AnimationCurve))
                    {
                        config.AddValue(targets[0].FieldName, memberValue);
                    }
                    else if (memberValue.GetType() == typeof(FloatCurve))
                    {
                        (memberValue as FloatCurve).Save(config.AddNode(targets[0].FieldName));
                    }
                    else if (memberValue is AnimationCurve)
                    {
                        new FloatCurve((memberValue as AnimationCurve).keys).Save(config.AddNode(targets[0].FieldName));
                    }
                }
                return(config);
            }
Exemplo n.º 31
0
 public static string GetDarklandsPath(ConfigType type)
 {
     return(ReadSetting <string>(
                type, SettingDarklandsPath));
 }
Exemplo n.º 32
0
 public Task <ConfigEntity> GetByKey(string key, ConfigType type = ConfigType.Custom, IUnitOfWork uow = null)
 {
     return(Db.Find(m => m.Key == key && m.Type == type).UseUow(uow).FirstAsync());
 }
Exemplo n.º 33
0
 public Task <IList <ConfigEntity> > QueryByType(ConfigType type)
 {
     return(Db.Find(m => m.Type == type).ToListAsync());
 }
Exemplo n.º 34
0
 public Task <bool> Exists(ConfigType type, string key)
 {
     return(ExistsAsync(m => m.Type == type && m.Key == key));
 }
Exemplo n.º 35
0
 protected bool load(ConfigType type)
 {
     return(readFromLocalConfigFile(type, instance));
 }
Exemplo n.º 36
0
        public Task <string> GetJson(ConfigType type, string code)
        {
            var json = ConfigJsons.FirstOrDefault(m => m.Key == $"{type.ToInt()}_{code.ToLower()}").Value;

            return(Task.FromResult(json));
        }
Exemplo n.º 37
0
        static void ExportSheetJson(ExcelWorksheet worksheet, string name,
                                    Dictionary <string, HeadInfo> classField, ConfigType configType, StringBuilder sb)
        {
            string configTypeStr = configType.ToString();

            for (int row = 6; row <= worksheet.Dimension.End.Row; ++row)
            {
                string prefix = worksheet.Cells[row, 2].Text.Trim();
                if (prefix.Contains("#"))
                {
                    continue;
                }

                if (prefix == "")
                {
                    prefix = "cs";
                }

                // 服务端因为机器人的存在必须包含客户端所有配置,所以单独的c字段没有意义,单独的c就表示cs
                if (prefix == "c")
                {
                    prefix = "cs";
                }

                if (!prefix.Contains(configTypeStr))
                {
                    continue;
                }

                if (worksheet.Cells[row, 3].Text.Trim() == "")
                {
                    continue;
                }

                sb.Append("{");
                sb.Append($"\"_t\":\"{name}\"");
                for (int col = 3; col <= worksheet.Dimension.End.Column; ++col)
                {
                    string fieldName = worksheet.Cells[4, col].Text.Trim();
                    if (!classField.ContainsKey(fieldName))
                    {
                        continue;
                    }

                    HeadInfo headInfo = classField[fieldName];

                    if (headInfo == null)
                    {
                        continue;
                    }

                    if (!headInfo.FieldCS.Contains(configTypeStr))
                    {
                        continue;
                    }

                    string fieldN = headInfo.FieldName;
                    if (fieldN == "Id")
                    {
                        fieldN = "_id";
                    }

                    sb.Append($",\"{fieldN}\":{Convert(headInfo.FieldType, worksheet.Cells[row, col].Text.Trim())}");
                }

                sb.Append("},\n");
            }
        }
Exemplo n.º 38
0
        static void ExportClass(string protoName, Dictionary <string, HeadInfo> classField, ConfigType configType)
        {
            string dir = GetClassDir(configType);

            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }

            string exportPath = Path.Combine(dir, $"{protoName}.cs");

            using FileStream txt  = new FileStream(exportPath, FileMode.Create);
            using StreamWriter sw = new StreamWriter(txt);

            StringBuilder sb = new StringBuilder();

            foreach ((string _, HeadInfo headInfo) in classField)
            {
                if (headInfo == null)
                {
                    continue;
                }

                if (!headInfo.FieldCS.Contains(configType.ToString()))
                {
                    continue;
                }

                sb.Append($"\t\t/// <summary>{headInfo.FieldDesc}</summary>\n");
                sb.Append($"\t\t[ProtoMember({headInfo.FieldIndex})]\n");
                string fieldType = headInfo.FieldType;
                sb.Append($"\t\tpublic {fieldType} {headInfo.FieldName} {{ get; set; }}\n");
            }

            string content = template.Replace("(ConfigName)", protoName).Replace(("(Fields)"), sb.ToString());

            sw.Write(content);
        }
Exemplo n.º 39
0
 public IResultModel Edit(string code, ConfigType type)
 {
     return(ResultModel.Success(_configProvider.Get(code, type)));
 }
Exemplo n.º 40
0
 private static Assembly GetAssembly(ConfigType configType)
 {
     return(configAssemblies[(int)configType]);
 }
Exemplo n.º 41
0
        /// <summary>
        /// Writes the XML element as YAML.
        /// </summary>
        private void WriteElement(YamlFormatArgs args, XElement xml, ConfigType ct, ConfigurationEntity entity, Type type)
        {
            WriteComments(args, xml);

            args.Indent += 2;
            if (args.Indent == 2)
            {
                args.Writer.Write("- { ");
            }
            else if (args.Indent > 0)
            {
                args.Writer.Write($"{new string(' ', args.Indent)}{{ ");
            }

            WriteAttributes(args, ct, entity, type, xml);

            // Group by element name, then process as a collection.
            int i    = 0;
            var coll = xml.Elements().GroupBy(x => x.Name).Select(g => new { g.Key, Children = xml.Elements(g.Key) });

            foreach (var grp in coll)
            {
                var info = GetEntityConfigInfo(grp.Key.LocalName);
                if (info.entity == ConfigurationEntity.None)
                {
                    return;
                }

                if (args.Indent > 0)
                {
                    args.Writer.WriteLine(",");
                    args.Indent += 2;
                    args.Writer.Write($"{new string(' ', args.Indent)}{info.name}:");
                }
                else
                {
                    args.Writer.Write($"{info.name}:");
                }

                if (args.Indent > 0)
                {
                    args.Writer.Write(" [");
                }

                args.Writer.WriteLine();
                int j = 0;

                foreach (var child in grp.Children)
                {
                    if (j++ > 0)
                    {
                        args.WriteClosingSquigglyBracket();
                        if (args.Indent > 0)
                        {
                            args.Writer.Write(",");
                        }

                        args.Writer.WriteLine();
                    }

                    if (args.Indent == 0 && !child.Equals(xml.Document.Root.Elements().First()))
                    {
                        args.Writer.WriteLine();
                    }

                    args.Level++;
                    WriteElement(args, child, ct, info.entity, info.type);
                    args.Level--;
                }

                args.WriteClosingSquigglyBracket();
                args.Writer.WriteLine();

                if (args.Indent > 0)
                {
                    args.Writer.Write($"{new string(' ', args.Indent)}]");
                    args.Indent -= 2;
                }

                i++;
                if (i == coll.Count())
                {
                    args.Writer.WriteLine();
                    if (args.Indent > 0)
                    {
                        args.Writer.Write($"{new string(' ', args.Indent)}");
                    }
                }
            }

            args.Indent -= 2;
        }
Exemplo n.º 42
0
        /// <summary>
        /// Load collection for ParserTargetCollection
        /// </summary>
        /// <param name="member">Member to load data for</param>
        /// <param name="o">Instance of the object which owns member</param>
        /// <param name="node">Configuration node from which to load data</param>
        /// <param name="configName">The name of the mod that corresponds to the entry in ParserOptions</param>
        /// <param name="getChildren">Whether getters on the object should get called</param>
        private static void LoadCollectionMemberFromConfigurationNode(MemberInfo member, Object o, ConfigNode node,
                                                                      String configName = "Default", Boolean getChildren = true)
        {
            // Get the target attributes
            ParserTargetCollection[] targets =
                (ParserTargetCollection[])member.GetCustomAttributes(typeof(ParserTargetCollection), true);

            // Process the target attributes
            foreach (ParserTargetCollection target in targets)
            {
                // Figure out if this field exists and if we care
                Boolean isNode  = node.HasNode(target.FieldName) || target.FieldName == "self";
                Boolean isValue = node.HasValue(target.FieldName);

                // Obtain the type the member is (can only be field or property)
                Type   targetType;
                Object targetValue = null;
                if (member.MemberType == MemberTypes.Field)
                {
                    targetType  = ((FieldInfo)member).FieldType;
                    targetValue = getChildren ? ((FieldInfo)member).GetValue(o) : null;
                }
                else
                {
                    targetType = ((PropertyInfo)member).PropertyType;
                    try
                    {
                        if (((PropertyInfo)member).CanRead && getChildren)
                        {
                            targetValue = ((PropertyInfo)member).GetValue(o, null);
                        }
                    }
                    catch (Exception)
                    {
                        // ignored
                    }
                }

                // Get settings data
                ParserOptions.Data data = ParserOptions.Options[configName];

                // Log
                data.LogCallback("Parsing Target " + target.FieldName + " in (" + o.GetType() + ") as (" + targetType +
                                 ")");

                // If there was no data found for this node
                if (!isNode && !isValue)
                {
                    if (!target.Optional && !(target.AllowMerge && targetValue != null))
                    {
                        // Error - non optional field is missing
                        throw new ParserTargetMissingException(
                                  "Missing non-optional field: " + o.GetType() + "." + target.FieldName);
                    }

                    // Nothing to do, so return
                    continue;
                }

                // If we are dealing with a generic collection
                if (targetType.IsGenericType)
                {
                    // If the target is a generic dictionary
                    if (typeof(IDictionary).IsAssignableFrom(targetType))
                    {
                        // We need a node for this decoding
                        if (!isNode)
                        {
                            throw new Exception("Loading a generic dictionary requires sources to be nodes");
                        }

                        // Get the target value as a dictionary
                        IDictionary collection = targetValue as IDictionary;

                        // Get the internal type of this collection
                        Type genericTypeA = targetType.GetGenericArguments()[0];
                        Type genericTypeB = targetType.GetGenericArguments()[1];

                        // Create a new collection if merge is disallowed or if the collection is null
                        if (collection == null || !target.AllowMerge)
                        {
                            collection  = Activator.CreateInstance(targetType) as IDictionary;
                            targetValue = collection;
                        }

                        // Process the node
                        ConfigNode targetNode = target.FieldName == "self" ? node : node.GetNode(target.FieldName);

                        // Check the config type
                        RequireConfigType[] attributes =
                            (RequireConfigType[])genericTypeA.GetCustomAttributes(typeof(RequireConfigType), true);
                        if (attributes.Length > 0)
                        {
                            if (attributes[0].Type == ConfigType.Node)
                            {
                                throw new ParserTargetTypeMismatchException(
                                          "The key value of a generic dictionary must be a Value");
                            }
                        }

                        attributes =
                            (RequireConfigType[])genericTypeB.GetCustomAttributes(typeof(RequireConfigType), true);
                        if (attributes.Length > 0 || genericTypeB == typeof(String))
                        {
                            ConfigType type = genericTypeB == typeof(String) ? ConfigType.Value : attributes[0].Type;
                            if (type == ConfigType.Node)
                            {
                                // Iterate over all of the nodes in this node
                                foreach (ConfigNode subnode in targetNode.nodes)
                                {
                                    // Check for the name significance
                                    switch (target.NameSignificance)
                                    {
                                    case NameSignificance.None:
                                        // Just processes the contents of the node
                                        collection.Add(ProcessValue(genericTypeA, subnode.name),
                                                       CreateObjectFromConfigNode(genericTypeB, subnode, configName,
                                                                                  target.GetChild));
                                        break;

                                    case NameSignificance.Type:
                                        throw new Exception(
                                                  "NameSignificance.Type isn't supported on generic dictionaries.");

                                    case NameSignificance.Key:
                                        throw new Exception(
                                                  "NameSignificance.Key isn't supported on generic dictionaries");

                                    default:
                                        throw new ArgumentOutOfRangeException();
                                    }
                                }
                            }
                            else
                            {
                                // Iterate over all of the values in this node
                                foreach (ConfigNode.Value value in targetNode.values)
                                {
                                    // Check for the name significance
                                    switch (target.NameSignificance)
                                    {
                                    case NameSignificance.None:
                                        collection.Add(ProcessValue(genericTypeA, value.name),
                                                       ProcessValue(genericTypeB, value.value));
                                        break;

                                    case NameSignificance.Type:
                                        throw new Exception(
                                                  "NameSignificance.Type isn't supported on generic dictionaries.");

                                    case NameSignificance.Key:
                                        throw new Exception(
                                                  "NameSignificance.Key isn't supported on generic dictionaries");

                                    default:
                                        throw new ArgumentOutOfRangeException();
                                    }
                                }
                            }
                        }
                    }

                    // If the target is a generic collection
                    else if (typeof(IList).IsAssignableFrom(targetType))
                    {
                        // We need a node for this decoding
                        if (!isNode)
                        {
                            throw new Exception("Loading a generic list requires sources to be nodes");
                        }

                        // Get the target value as a collection
                        IList collection = targetValue as IList;

                        // Get the internal type of this collection
                        Type genericType = targetType.GetGenericArguments()[0];

                        // Create a new collection if merge is disallowed or if the collection is null
                        if (collection == null || !target.AllowMerge)
                        {
                            collection  = Activator.CreateInstance(targetType) as IList;
                            targetValue = collection;
                        }

                        // Store the objects that were already patched
                        List <Object> patched = new List <Object>();

                        // Process the node
                        ConfigNode targetNode = target.FieldName == "self" ? node : node.GetNode(target.FieldName);

                        // Check the config type
                        RequireConfigType[] attributes =
                            (RequireConfigType[])genericType.GetCustomAttributes(typeof(RequireConfigType), true);
                        if (attributes.Length > 0 || genericType == typeof(String))
                        {
                            ConfigType type = genericType == typeof(String) ? ConfigType.Value : attributes[0].Type;
                            if (type == ConfigType.Node)
                            {
                                // Iterate over all of the nodes in this node
                                foreach (ConfigNode subnode in targetNode.nodes)
                                {
                                    // Check for the name significance
                                    switch (target.NameSignificance)
                                    {
                                    case NameSignificance.None:
                                    case NameSignificance.Key when subnode.name == target.Key:

                                        // Check if the type represents patchable data
                                        Object current = null;
                                        if (typeof(IPatchable).IsAssignableFrom(genericType) &&
                                            collection.Count > 0)
                                        {
                                            for (Int32 i = 0; i < collection.Count; i++)
                                            {
                                                if (collection[i].GetType() != genericType)
                                                {
                                                    continue;
                                                }

                                                if (patched.Contains(collection[i]))
                                                {
                                                    continue;
                                                }

                                                IPatchable patchable = (IPatchable)collection[i];
                                                PatchData  patchData =
                                                    CreateObjectFromConfigNode <PatchData>(subnode, "Internal");
                                                if (patchData.name == patchable.name)
                                                {
                                                    // Name matches, check for an index
                                                    if (patchData.index == collection.IndexOf(collection[i]))
                                                    {
                                                        // Both values match
                                                        current = collection[i];
                                                        break;
                                                    }

                                                    if (patchData.index > -1)
                                                    {
                                                        // Index doesn't match, continue
                                                        continue;
                                                    }

                                                    // Name matches, and no index exists
                                                    current = collection[i];
                                                    break;
                                                }

                                                if (patchData.name != null)
                                                {
                                                    // The name doesn't match, continue the search
                                                    continue;
                                                }

                                                // We found the first object that wasn't patched yet
                                                current = collection[i];
                                                break;
                                            }
                                        }

                                        // If no object was found, check if the type implements custom constructors
                                        if (current == null)
                                        {
                                            current = Activator.CreateInstance(genericType);
                                            collection?.Add(current);
                                        }

                                        // Parse the config node into the object
                                        LoadObjectFromConfigurationNode(current, subnode, configName,
                                                                        target.GetChild);
                                        patched.Add(current);
                                        if (collection != null)
                                        {
                                            collection[collection.IndexOf(current)] = current;
                                        }

                                        break;

                                    case NameSignificance.Type:

                                        // Generate the type from the name
                                        Type elementType = ModTypes.FirstOrDefault(t =>
                                                                                   t.Name == subnode.name &&
                                                                                   !Equals(t.Assembly, typeof(HighLogic).Assembly) &&
                                                                                   genericType.IsAssignableFrom(t));

                                        // Check if the type represents patchable data
                                        current = null;
                                        if (typeof(IPatchable).IsAssignableFrom(elementType) &&
                                            collection.Count > 0)
                                        {
                                            for (Int32 i = 0; i < collection.Count; i++)
                                            {
                                                if (collection[i].GetType() != elementType)
                                                {
                                                    continue;
                                                }

                                                if (patched.Contains(collection[i]))
                                                {
                                                    continue;
                                                }

                                                IPatchable patchable = (IPatchable)collection[i];
                                                PatchData  patchData =
                                                    CreateObjectFromConfigNode <PatchData>(subnode, "Internal");
                                                if (patchData.name == patchable.name)
                                                {
                                                    // Name matches, check for an index
                                                    if (patchData.index == i)
                                                    {
                                                        // Both values match
                                                        current = collection[i];
                                                        break;
                                                    }

                                                    if (patchData.index > -1)
                                                    {
                                                        // Index doesn't match, continue
                                                        continue;
                                                    }

                                                    // Name matches, and no index exists
                                                    current = collection[i];
                                                    break;
                                                }

                                                if (patchData.name != null)
                                                {
                                                    // The name doesn't match, continue the search
                                                    continue;
                                                }

                                                // We found the first object that wasn't patched yet
                                                current = collection[i];
                                                break;
                                            }
                                        }

                                        // If no object was found, check if the type implements custom constructors
                                        if (current == null)
                                        {
                                            current = Activator.CreateInstance(elementType);
                                            collection?.Add(current);
                                            if (typeof(ICreatable).IsAssignableFrom(elementType))
                                            {
                                                ICreatable creatable = (ICreatable)current;
                                                creatable.Create();
                                            }
                                        }

                                        // Parse the config node into the object
                                        LoadObjectFromConfigurationNode(current, subnode, configName,
                                                                        target.GetChild);
                                        patched.Add(current);
                                        if (collection != null)
                                        {
                                            collection[collection.IndexOf(current)] = current;
                                        }

                                        break;

                                    default:
                                        continue;
                                    }
                                }
                            }
                            else
                            {
                                // Iterate over all of the nodes in this node
                                foreach (ConfigNode.Value value in targetNode.values)
                                {
                                    // Check for the name significance
                                    switch (target.NameSignificance)
                                    {
                                    case NameSignificance.None:

                                        // Just processes the contents of the node
                                        collection?.Add(ProcessValue(genericType, value.value));
                                        break;

                                    case NameSignificance.Type:

                                        // Generate the type from the name
                                        Type elementType = ModTypes.FirstOrDefault(t =>
                                                                                   t.Name == value.name &&
                                                                                   !Equals(t.Assembly, typeof(HighLogic).Assembly) &&
                                                                                   genericType.IsAssignableFrom(t));

                                        // Add the object to the collection
                                        collection?.Add(ProcessValue(elementType, value.value));
                                        break;

                                    case NameSignificance.Key when value.name == target.Key:

                                        // Just processes the contents of the node
                                        collection?.Add(ProcessValue(genericType, value.value));
                                        break;

                                    default:
                                        continue;
                                    }
                                }
                            }
                        }
                    }
                }

                // If we are dealing with a non generic collection
                else
                {
                    // Check for invalid scenarios
                    if (target.NameSignificance == NameSignificance.None)
                    {
                        throw new Exception(
                                  "Can not infer type from non generic target; can not infer type from zero name significance");
                    }
                }

                // If the member type is a field, set the value
                if (member.MemberType == MemberTypes.Field)
                {
                    ((FieldInfo)member).SetValue(o, targetValue);
                }

                // If the member wasn't a field, it must be a property.  If the property is writable, set it.
                else if (((PropertyInfo)member).CanWrite)
                {
                    ((PropertyInfo)member).SetValue(o, targetValue, null);
                }
            }
        }
Exemplo n.º 43
0
        private static IAsyncResult QueryItemFromServerAsync(string key, ConfigType type, Action <ConfigItem, Exception> callback)
        {
            string url = new UrlBuilder()
                         .SetPath("/ActiveConfig/v1/GetKey")
                         .AddParam("appid", _appKey)
                         .AddParam("secretkey", _appSecret)
                         .AddParam("key", key + ":" + (int)type)
                         .GetUrl();

            return(Http.GetStringAsync(url, (s, e) =>
            {
                ConfigItem result = null;
                if (e == null)
                {
                    result = null;

                    try
                    {
                        var dict = JSON.Parse(s);
                        if (dict != null)
                        {
                            string code = dict["code"].Value;
                            string msg = dict["msg"].Value;
                            string data = dict["data"].Value;

                            if (code != "0")
                            {
                                Debug.WriteLine("Server return error {0}: {1}", code, msg);
                                e = new ActiveConfigException(msg);
                            }
                            else
                            {
                                if (dict["data"].Count == 1)
                                {
                                    var item = dict["data"][0];
                                    result = new ConfigItem();
                                    result.Key = item["key"].Value;
                                    result.Value = item["value"].Value;
                                    result.Type = (ConfigType)Enum.Parse(typeof(ConfigType), item["type"].Value, true);
                                    result.ExpireTime = Helper.ConvertTime(item["endtime"].Value);
                                    result.MD5 = item["md5"].Value;
                                    result.ID = string.Format("{0}:{1}", (int)result.Type, result.Key);
                                    if (result.Status == ItemStatus.KeyNotFound)
                                    {
                                        e = new KeyNotFoundException(key);
                                    }
                                }
                                else
                                {
                                    e = new KeyNotFoundException(key);
                                }
                            }
                        }
                        else
                        {
                            e = new ActiveConfigException("Parsing json failed");
                        }
                    }
                    catch (Exception err)
                    {
                        e = new ActiveConfigException("Parsing json failed", err);
                    }
                }

                callback(result, e);
            }));
        }
Exemplo n.º 44
0
 public ConfigPathAttribute(string name, ConfigType typ, bool stable = true)
 {
     assetName  = name;
     isStable   = stable;
     configType = typ;
 }
Exemplo n.º 45
0
        static void ExportSheetClass(ExcelWorksheet worksheet, List<HeadInfo> classField, HashSet<string> uniqeField, ConfigType configType)
        {
            const int row = 2;
            for (int col = 3; col <= worksheet.Dimension.End.Column; ++col)
            {
                string fieldName = worksheet.Cells[row + 2, col].Text.Trim();
                if (fieldName == "")
                {
                    continue;
                }
                if (!uniqeField.Add(fieldName))
                {
                    continue;
                }
                string fieldCS = worksheet.Cells[row, col].Text.Trim();
                string fieldDesc = worksheet.Cells[row + 1, col].Text.Trim();
                string fieldType = worksheet.Cells[row + 3, col].Text.Trim();

                classField.Add(new HeadInfo(fieldCS, fieldDesc, fieldName, fieldType));
            }
        }
        /// <summary>
        /// Displays a parser target in the window
        /// </summary>
        private void DisplayParserTarget(ParserTarget target, MemberInfo member)
        {
            // Don't display hidden options
            if (Tools.HasAttribute <KittopiaHideOption>(member) &&
                !Tools.GetAttributes <KittopiaHideOption>(member)[0].Show)
            {
                return;
            }

            // Check if the object is a list or a single element
            if (!Tools.IsCollection(target))
            {
                GUIHorizontalLayout(() =>
                {
                    GUILabel(target.FieldName, modifier: Alignment(TextAlignmentOptions.Left));
                    GUIFlexibleSpace();
                    GUILabel(target.Optional ? "Optional" : "Required",
                             modifier: Alignment(TextAlignmentOptions.Right)
                             .And(TextColor(Color.gray)));
                });

                // Display a KittopiaDescription
                String description = Tools.GetDescription(member);
                if (!String.IsNullOrEmpty(description))
                {
                    GUISpace(2f);
                    GUILabel(description,
                             modifier: TextColor(Color.gray));
                }

                GUISpace(5f);

                // If the element is loaded from a config node, it needs a new window
                // Simply values can be edited with an inline textfield
                ConfigType configType =
                    Tools.GetConfigType(Tools.GetValue(member, Info.Value)?.GetType() ?? Tools.MemberType(member));

                if (configType == ConfigType.Node)
                {
                    GUIHorizontalLayout(() =>
                    {
                        // Edit Button
                        GUIToggleButton(
                            () => Children.ContainsKey(target.FieldName) && Children[target.FieldName].IsVisible,
                            "Edit", e => ToggleSubEditor(target, member, e), -1f, 25f,
                            Enabled <DialogGUIToggleButton>(() => Tools.GetValue(member, Info.Value) != null));

                        // Button to create or destroy the element
                        if (Tools.HasAttribute <KittopiaUntouchable>(member))
                        {
                            GUIButton(Tools.GetValue(member, Info.Value) != null ? "x" : "+", () => { }, 25f, 25f,
                                      false, () => { }, Enabled <DialogGUIButton>(() => false));
                        }
                        else
                        {
                            GUIButton(() => Tools.GetValue(member, Info.Value) != null ? "x" : "+", () =>
                            {
                                Object value = Tools.GetValue(member, Info.Value);
                                if (value != null)
                                {
                                    Tools.Destruct(value);
                                    Tools.SetValue(member, Info.Value, null);
                                    SetValue(null);
                                }
                                else
                                {
                                    Object v = Tools.Construct(Tools.MemberType(member), Info.Body);
                                    Tools.SetValue(member, Info.Value, v);
                                    SetValue(v);
                                }
                            }, 25f, 25f, false,
                                      () => { });
                        }
                    });
                }
                else
                {
                    GUIHorizontalLayout(() =>
                    {
                        GUITextInput("", false, Int32.MaxValue, s => Tools.ApplyInput(member, s, Info.Value),
                                     () => Tools.FormatParsable(Tools.GetValue(member, Info.Value)) ?? "",
                                     TMP_InputField.ContentType.Standard, 25f);
                        GUIToggleButton(
                            () => ValueEditors.ContainsKey(target.FieldName) &&
                            ValueEditors[target.FieldName].IsVisible, ">",
                            e => ToggleValueEditor(target, member, e), 25f, 25f,
                            Enabled <DialogGUIToggleButton>(() => HasValueEditor(member)));
                    });
                }
            }
            else
            {
                ParserTargetCollection collection = (ParserTargetCollection)target;

                // Is the collection parsing a subnode, or this one?
                if (collection.FieldName != "self")
                {
                    GUIHorizontalLayout(() =>
                    {
                        GUILabel(target.FieldName, modifier: Alignment(TextAlignmentOptions.Left));
                        GUIFlexibleSpace();
                        GUILabel(target.Optional ? "Optional" : "Required",
                                 modifier: Alignment(TextAlignmentOptions.Right)
                                 .And(TextColor(Color.gray)));
                    });

                    // Display a KittopiaDescription
                    String description = Tools.GetDescription(member);
                    if (!String.IsNullOrEmpty(description))
                    {
                        GUISpace(2f);
                        GUILabel(description,
                                 modifier: TextColor(Color.gray));
                    }

                    GUISpace(5f);

                    GUIHorizontalLayout(() =>
                    {
                        // Edit Button
                        GUIToggleButton(() => Children.ContainsKey(target.FieldName) && Children[target.FieldName].IsVisible, "Edit", e => ToggleCollectionEditor(target, member, e), -1f, 25f,
                                        Enabled <DialogGUIToggleButton>(() => Tools.GetValue(member, Info.Value) != null));

                        // Button to create or destroy the element
                        if (Tools.HasAttribute <KittopiaUntouchable>(member))
                        {
                            GUIButton(Tools.GetValue(member, Info.Value) != null ? "x" : "+", () => { }, 25f, 25f,
                                      false, () => { }, Enabled <DialogGUIButton>(() => false));
                        }
                        else
                        {
                            GUIButton(() => Tools.GetValue(member, Info.Value) != null ? "x" : "+", () =>
                            {
                                Object value = Tools.GetValue(member, Info.Value);
                                if (value != null)
                                {
                                    Tools.Destruct(value);
                                    Tools.SetValue(member, Info.Value, null);
                                    SetValue(null);
                                }
                                else
                                {
                                    Object v = Tools.Construct(Tools.MemberType(member), Info.Body);
                                    Tools.SetValue(member, Info.Value, v);
                                    SetValue(v);
                                }
                            }, 25f, 25f, false,
                                      () => { });
                        }
                    });
                }
                else
                {
                    new CollectionEditor(() => Tools.GetValue(member, Info.Value),
                                         v => Tools.SetValue(member, Info.Value, v), Info.Body,
                                         Info.Body.transform.name + " - " + target.FieldName, member, (ParserTargetCollection)target,
                                         () => Info.Value).DisplayCollection();
                }
            }

            if (target.FieldName != "self")
            {
                // Use a box as a seperator
                GUISpace(5f);
                GUIBox(-1f, 1f, () => { });
                GUISpace(5f);
            }
        }
Exemplo n.º 47
0
 public void DeleteConfigType(ConfigType data)
 {
     try {
     SetService();  SerClient.DeleteConfigType(data); }
     finally
     {
         SerClient.Close();
         if (SerClient.State == CommunicationState.Faulted)
         SerClient.Abort(); 
     }
 }
Exemplo n.º 48
0
        public void GetString_NullResourceKey_ThrowsArgumentNullException(ConfigType config)
        {
            var localizer = NewLocalizer(config);

            Assert.Throws <ArgumentNullException>(() => localizer[null]);
        }
Exemplo n.º 49
0
 public Config(ConfigType type)
 {
     this.type = type;
 }
Exemplo n.º 50
0
        ///-----------------------------------------------------------------------------
        /// <summary>
        /// Removes profanity words in the provided input string.
        /// </summary>
        /// <remarks>
        /// The words to search could be defined in two different places:
        /// 1) In an external file. (NOT IMPLEMENTED)
        /// 2) In System/Site lists.
        /// The name of the System List is "ProfanityFilter". The name of the list in each portal is composed using the following rule:
        /// "ProfanityFilter-" + PortalID.
        /// </remarks>
        /// <param name="inputString">The string to search the words in.</param>
        /// <param name="configType">The type of configuration.</param>
        /// <param name="configSource">The external file to search the words. Ignored when configType is ListController.</param>
        /// <param name="filterScope">When using ListController configType, this parameter indicates which list(s) to use.</param>
        /// <returns>The original text with the profanity words removed.</returns>
        ///-----------------------------------------------------------------------------
        public string Remove(string inputString, ConfigType configType, string configSource, FilterScope filterScope)
        {
            switch (configType)
            {
                case ConfigType.ListController:
                    const RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Singleline;
                    const string listName = "ProfanityFilter";
            
                    var listController = new ListController();
                
                    PortalSettings settings;

                    IEnumerable<ListEntryInfo> listEntryHostInfos;
                    IEnumerable<ListEntryInfo> listEntryPortalInfos;
            
                    switch (filterScope)
                    {
                        case FilterScope.SystemList:
                            listEntryHostInfos = listController.GetListEntryInfoItems(listName, "", Null.NullInteger);
                            inputString = listEntryHostInfos.Aggregate(inputString, (current, removeItem) => Regex.Replace(current, @"\b" + removeItem.Text + @"\b", string.Empty, options));
                            break;
                        case FilterScope.SystemAndPortalList:
                            settings = PortalController.GetCurrentPortalSettings();
                            listEntryHostInfos = listController.GetListEntryInfoItems(listName, "", Null.NullInteger);
                            listEntryPortalInfos = listController.GetListEntryInfoItems(listName + "-" + settings.PortalId, "", settings.PortalId);
                            inputString = listEntryHostInfos.Aggregate(inputString, (current, removeItem) => Regex.Replace(current, @"\b" + removeItem.Text + @"\b", string.Empty, options));
                            inputString = listEntryPortalInfos.Aggregate(inputString, (current, removeItem) => Regex.Replace(current, @"\b" + removeItem.Text + @"\b", string.Empty, options));
                            break;
                        case FilterScope.PortalList:
                            settings = PortalController.GetCurrentPortalSettings();
                            listEntryPortalInfos = listController.GetListEntryInfoItems(listName + "-" + settings.PortalId, "", settings.PortalId);
                            inputString = listEntryPortalInfos.Aggregate(inputString, (current, removeItem) => Regex.Replace(current, @"\b" + removeItem.Text + @"\b", string.Empty, options));        
                            break;
                    }

                    break;
                case ConfigType.ExternalFile:
                    throw new NotImplementedException();
                default:
                    throw new ArgumentOutOfRangeException("configType");
            }

            return inputString;
        }
Exemplo n.º 51
0
 public DoubleData(ConfigType configType, string prefix, string name, string description, string editor, double defaultValue)
     : base(configType, prefix, name, description, editor, defaultValue)
 {
 }
Exemplo n.º 52
0
 public ListData(ConfigType configType, string prefix, string name, string description, string editor)
     : base(configType, prefix, name, description, editor)
 {
     childStruct = null;
 }
Exemplo n.º 53
0
        public void WithCultureGetAllStrings_WithoutParentCulture_ReturnsSpecificCultureStrings(ConfigType config)
        {
            var localizer = NewLocalizer(config);

            var expected = new[] {
                new LocalizedString("Colour", "Colour", false),
                new LocalizedString("Overridden", "Overriding an earlier config", false)
            };

            var auLocalizer = localizer.WithCulture(new CultureInfo("en-AU"));
            var values      = auLocalizer.GetAllStrings(includeParentCultures: false);

            Assert.Equal(expected, values.ToArray(), LocalizedStringEqualityComparer);
        }
Exemplo n.º 54
0
        // 动态编译生成的cs代码
        private static Assembly DynamicBuild(ConfigType configType)
        {
            string            classPath   = GetClassDir(configType);
            List <SyntaxTree> syntaxTrees = new List <SyntaxTree>();
            List <string>     protoNames  = new List <string>();

            foreach (string classFile in Directory.GetFiles(classPath, "*.cs"))
            {
                protoNames.Add(Path.GetFileNameWithoutExtension(classFile));
                syntaxTrees.Add(CSharpSyntaxTree.ParseText(File.ReadAllText(classFile)));
            }

            List <PortableExecutableReference> references = new List <PortableExecutableReference>();

            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
            foreach (Assembly assembly in assemblies)
            {
                try
                {
                    if (assembly.IsDynamic)
                    {
                        continue;
                    }

                    if (assembly.Location == "")
                    {
                        continue;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    throw;
                }

                PortableExecutableReference reference = MetadataReference.CreateFromFile(assembly.Location);
                references.Add(reference);
            }

            CSharpCompilation compilation = CSharpCompilation.Create(null,
                                                                     syntaxTrees.ToArray(),
                                                                     references.ToArray(),
                                                                     new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));

            using MemoryStream memSteam = new MemoryStream();

            EmitResult emitResult = compilation.Emit(memSteam);

            if (!emitResult.Success)
            {
                StringBuilder stringBuilder = new StringBuilder();
                foreach (Diagnostic t in emitResult.Diagnostics)
                {
                    stringBuilder.AppendLine(t.GetMessage());
                }

                throw new Exception($"动态编译失败:\n{stringBuilder}");
            }

            memSteam.Seek(0, SeekOrigin.Begin);

            Assembly ass = Assembly.Load(memSteam.ToArray());

            return(ass);
        }
Exemplo n.º 55
0
        /// <summary>
        /// Outputs an ARTag configuration file based on the marker layout. 
        /// </summary>
        /// <param name="configFilename">The name of the configuration file to be generated</param>
        /// <param name="type">The type of config file depending on different tracking libraries</param>
        /// <exception cref="InvalidOperationException"></exception>
        public void OutputConfig(String configFilename, ConfigType type)
        {
            int id = 0;
            foreach (int key in configs.Keys)
            {
                id = key;
                break;
            }

            float ratio = markerSize / configs[id].Size.Width;

            try
            {
                XmlDocument xmlDoc = new XmlDocument();
                XmlDeclaration xmlDeclaration = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", "no");
                xmlDoc.InsertBefore(xmlDeclaration, xmlDoc.DocumentElement);

                if (type == ConfigType.ALVAR)
                {
                    XmlElement xmlRootNode = xmlDoc.CreateElement("multimarker");
                    xmlRootNode.SetAttribute("markers", markerIDs.Count.ToString());
                    xmlDoc.AppendChild(xmlRootNode);

                    foreach (int markerID in markerIDs)
                    {
                        XmlElement markerXml = xmlDoc.CreateElement("marker");
                        markerXml.SetAttribute("index", markerID.ToString());
                        markerXml.SetAttribute("status", "2");

                        MarkerConfig config = configs[markerID];

                        int x = config.Position.X - configCenter.X;
                        int y = config.Position.Y - configCenter.Y;

                        PointF configPos = new PointF(x * ratio, y * ratio);
                        SizeF configSize = new SizeF(config.Size.Width * ratio, config.Size.Height * ratio);

                        XmlElement[] cornerXml = new XmlElement[4];
                        cornerXml[0] = xmlDoc.CreateElement("corner");
                        cornerXml[0].SetAttribute("x", configPos.X.ToString());
                        cornerXml[0].SetAttribute("y", "" + (-(configPos.Y + configSize.Height)));
                        cornerXml[0].SetAttribute("z", "0");

                        cornerXml[1] = xmlDoc.CreateElement("corner");
                        cornerXml[1].SetAttribute("x", "" + (configPos.X + configSize.Width));
                        cornerXml[1].SetAttribute("y", "" + (-(configPos.Y + configSize.Height)));
                        cornerXml[1].SetAttribute("z", "0");

                        cornerXml[2] = xmlDoc.CreateElement("corner");
                        cornerXml[2].SetAttribute("x", "" + (configPos.X + configSize.Width));
                        cornerXml[2].SetAttribute("y", "" + (-configPos.Y));
                        cornerXml[2].SetAttribute("z", "0");

                        cornerXml[3] = xmlDoc.CreateElement("corner");
                        cornerXml[3].SetAttribute("x", "" + configPos.X);
                        cornerXml[3].SetAttribute("y", "" + (-configPos.Y));
                        cornerXml[3].SetAttribute("z", "0");

                        foreach (XmlElement corner in cornerXml)
                            markerXml.AppendChild(corner);

                        xmlRootNode.AppendChild(markerXml);
                    }
                }
                else if (type == ConfigType.NyARToolkitPattern)
                {
                    XmlElement xmlRootNode = xmlDoc.CreateElement("multimarker");
                    xmlRootNode.SetAttribute("markers", markerIDs.Count.ToString());
                    xmlDoc.AppendChild(xmlRootNode);

                    foreach (int markerID in markerIDs)
                    {
                        XmlElement markerXml = xmlDoc.CreateElement("marker");

                        MarkerConfig config = configs[markerID];

                        string patternName = "";
                        int patternWidth = 16;
                        int patternHeight = 16;
                        float patternSize = markerSize;
                        float confidence = 0.5f;

                        if (config.AdditionalInfo != null)
                        {
                            foreach (KeyValuePair<string, string> pair in config.AdditionalInfo)
                            {
                                switch (pair.Key)
                                {
                                    case "patternName":
                                        patternName = pair.Value;
                                        break;
                                    case "patternWidth":
                                        patternWidth = int.Parse(pair.Value);
                                        break;
                                    case "patternHeight":
                                        patternHeight = int.Parse(pair.Value);
                                        break;
                                    case "confidence":
                                        confidence = float.Parse(pair.Value);
                                        break;
                                }
                            }
                        }

                        if (String.IsNullOrEmpty(patternName))
                            throw new Exception("You need to have a patternName information for marker: ");

                        markerXml.SetAttribute("patternName", patternName);
                        markerXml.SetAttribute("patternWidth", patternWidth.ToString());
                        markerXml.SetAttribute("patternHeight", patternHeight.ToString());
                        markerXml.SetAttribute("patternSize", patternSize.ToString());
                        markerXml.SetAttribute("confidence", confidence.ToString());

                        int x = config.Position.X - configCenter.X;
                        int y = config.Position.Y - configCenter.Y;

                        float fx = x * ratio;
                        float fy = y * ratio;

                        markerXml.SetAttribute("upperLeftCorner", fx + "," + fy);

                        xmlRootNode.AppendChild(markerXml);
                    }
                } 
                else if(type == ConfigType.NyARToolkitID)
                {
                    XmlElement xmlRootNode = xmlDoc.CreateElement("multimarker");
                    xmlRootNode.SetAttribute("markers", markerIDs.Count.ToString());
                    xmlDoc.AppendChild(xmlRootNode);

                    foreach (int markerID in markerIDs)
                    {
                        XmlElement markerXml = xmlDoc.CreateElement("marker");

                        MarkerConfig config = configs[markerID];

                        string patternId = "";
                        float patternSize = markerSize;

                        if (config.AdditionalInfo != null)
                        {
                            foreach (KeyValuePair<string, string> pair in config.AdditionalInfo)
                            {
                                switch (pair.Key)
                                {
                                    case "patternId":
                                        patternId = pair.Value;
                                        break;
                                }
                            }
                        }

                        if (String.IsNullOrEmpty(patternId))
                            throw new Exception("You need to have a patternName information for marker: ");

                        markerXml.SetAttribute("patternId", patternId);
                        markerXml.SetAttribute("patternSize", patternSize.ToString());

                        int x = config.Position.X - configCenter.X + (config.Size.Width / 2);
                        int y = config.Position.Y - configCenter.Y + (config.Size.Height / 2);

                        float fx = x * ratio;
                        float fy = y * ratio;

                        markerXml.SetAttribute("center", fx + "," + fy);

                        xmlRootNode.AppendChild(markerXml);
                    }
                }

                if (!Path.GetExtension(configFilename).Equals(".xml"))
                    configFilename += ".xml";

                xmlDoc.Save(configFilename);
            }
            catch (Exception exp)
            {
                Console.WriteLine(exp.Message + exp.StackTrace);
            }
        }
Exemplo n.º 56
0
        /// <summary>
        /// Adds a multi-value ParserTarget to the ConfigNode tree
        /// </summary>
        private static void ProcessCollection(ParserTarget parserTarget, MemberInfo memberInfo, Object reference,
                                              ref ConfigNode node)
        {
            // Get the type of the collection
            Type memberType = Tools.MemberType(memberInfo);

            // Is the collection a dictionary?
            if (typeof(IDictionary).IsAssignableFrom(memberType))
            {
                // Is the dictionary null?
                if (!(Tools.GetValue(memberInfo, reference) is IDictionary dictionary))
                {
                    return;
                }

                // Create the new ConfigNode
                ConfigNode targetNode = null;

                // Iterate over the elements of the dictionary
                foreach (DictionaryEntry value in dictionary)
                {
                    // Null-Check
                    if (value.Key == null || value.Value == null)
                    {
                        continue;
                    }

                    // Create the node if necessary
                    if (targetNode == null)
                    {
                        targetNode = node;
                        if (parserTarget.FieldName != "self")
                        {
                            // Get a description
                            String description = Tools.GetDescription(memberInfo);

                            // Add it to the config
                            targetNode = String.IsNullOrEmpty(description)
                                ? node.AddNode(parserTarget.FieldName)
                                : node.AddNode(parserTarget.FieldName, description);
                        }
                    }

                    // The first generic type has to be ConfigType.Value, figure out the type of the second one
                    ConfigType type = Tools.GetConfigType(value.Value.GetType());

                    // If it is a node, add it to the node
                    if (type == ConfigType.Node)
                    {
                        ConfigNode valueNode = targetNode.AddNode(Tools.FormatParsable(value.Key));
                        WriteToConfig(value.Value, ref valueNode);
                    }
                    else
                    {
                        targetNode.AddValue(Tools.FormatParsable(value.Key), Tools.FormatParsable(value.Value));
                    }
                }
            }
            else if (typeof(IList).IsAssignableFrom(memberType))
            {
                // Is the dictionary null?
                if (!(Tools.GetValue(memberInfo, reference) is IList list))
                {
                    return;
                }

                // Create the new ConfigNode
                ConfigNode targetNode = null;

                // Iterate over the elements of the list
                foreach (Object value in list)
                {
                    // Null-Check
                    if (value == null)
                    {
                        continue;
                    }

                    // Create the node if necessary
                    if (targetNode == null)
                    {
                        targetNode = node;
                        if (parserTarget.FieldName != "self")
                        {
                            // Get a description
                            String description = Tools.GetDescription(memberInfo);

                            // Add it to the config
                            targetNode = String.IsNullOrEmpty(description)
                                ? node.AddNode(parserTarget.FieldName)
                                : node.AddNode(parserTarget.FieldName, description);
                        }
                    }

                    // Figure out the config type of type
                    ConfigType type = Tools.GetConfigType(value.GetType());

                    // If it is a node, add it to the node
                    if (type == ConfigType.Node)
                    {
                        String name = "Value";
                        switch (parserTarget.NameSignificance)
                        {
                        case NameSignificance.Key:
                            name = parserTarget.Key;
                            break;

                        case NameSignificance.Type:
                            name = value.GetType().Name;
                            break;

                        case NameSignificance.None:
                            break;

                        default:
                            throw new ArgumentOutOfRangeException();
                        }

                        ConfigNode valueNode = targetNode.AddNode(name);
                        WriteToConfig(value, ref valueNode);
                    }
                    else
                    {
                        String name = "value";
                        switch (parserTarget.NameSignificance)
                        {
                        case NameSignificance.Key:
                            name = parserTarget.Key;
                            break;

                        case NameSignificance.Type:
                            name = value.GetType().Name;
                            break;

                        case NameSignificance.None:
                            break;

                        default:
                            throw new ArgumentOutOfRangeException();
                        }

                        targetNode.AddValue(name, Tools.FormatParsable(value));
                    }
                }
            }
        }
Exemplo n.º 57
0
        public bool Set(ConfigType type, string plugin, string key, object value)
        {
            if (!this.IsRegistered(plugin, key))
            {
                return(false);
            }

            ConfigType dbType = this.GetType(plugin, key);

            if (dbType != type)
            {
                throw new InvalidCastException("Can't replace type " + dbType.ToString() + " with type " + type.ToString() + " at " + key + "@" + plugin);
            }
            if (type == ConfigType.Custom)
            {
                throw new ArgumentException("Can not set type Custom!");
            }

            plugin = plugin.ToLower();
            key    = key.ToLower();
            string format;

            if (!this.Exists(plugin, key))
            {
                format = "INSERT INTO CORE_Settings VALUES ('{0}', '{1}', '{2}', '{3}')";
            }
            else
            {
                format = "UPDATE CORE_Settings SET Value = '{3}', Type = '{2}' WHERE Section = '{0}' AND Key = '{1}'";
            }

            try
            {
                string valueString;
                switch (type)
                {
                case ConfigType.Color:
                    if (!Regex.Match((string)value, "^[#]?[0-9a-f]{6}$", RegexOptions.IgnoreCase).Success)
                    {
                        return(false);
                    }
                    valueString = (string)value;
                    if (valueString.Length == 7)
                    {
                        valueString = valueString.Substring(1);
                    }
                    break;

                case ConfigType.String:
                    valueString = (string)value;
                    ConfigurationEntry stringEntry = this.GetEntry(plugin, key);
                    if (stringEntry.Values != null && stringEntry.Values.Length > 0)
                    {
                        List <object> values = new List <object>(stringEntry.Values);
                        if (!values.Contains(value))
                        {
                            return(false);
                        }
                    }
                    break;

                case ConfigType.Password:
                    valueString = (string)value;
                    break;

                case ConfigType.Integer:
                    valueString = ((Int32)value).ToString();
                    ConfigurationEntry intEntry = this.GetEntry(plugin, key);
                    bool result = (intEntry.Values.Length < 1);
                    foreach (object intEntryValue in intEntry.Values)
                    {
                        try
                        {
                            if ((Int32)intEntryValue == (Int32)value)
                            {
                                result = true;
                            }
                        }
                        catch { }
                    }
                    if (!result)
                    {
                        return(false);
                    }
                    break;

                case ConfigType.Boolean:
                    valueString = "false";
                    if ((Boolean)value)
                    {
                        valueString = "true";
                    }
                    break;

                case ConfigType.Date:
                    valueString = TimeStamp.FromDateTime((DateTime)value).ToString();
                    break;

                case ConfigType.Time:
                    valueString = ((TimeSpan)value).Ticks.ToString();
                    break;

                case ConfigType.Dimension:
                    valueString = ((Server)value).ToString();
                    break;

                case ConfigType.Username:
                    if (this.Parent.GetUserID((string)value) < 1)
                    {
                        return(false);
                    }
                    valueString = (string)value;
                    break;

                default:
                    return(false);
                }
                string query = string.Format(format, Config.EscapeString(plugin), Config.EscapeString(key), type.ToString(), Config.EscapeString(valueString));
                if (this.Config.ExecuteNonQuery(query) > 0)
                {
                    ConfigurationChangedArgs args = new ConfigurationChangedArgs(type, plugin, key, value);
                    this.Parent.Events.OnConfigurationChanged(this.Parent, args);
                    return(true);
                }
            }
            catch { }
            return(false);
        }
Exemplo n.º 58
0
        public object Get(ConfigType type, string plugin, string key, object defaultValue)
        {
            if (!this.IsRegistered(plugin, key))
            {
                return(defaultValue);
            }

            ConfigType dbType = this.GetType(plugin, key);
            bool       exists = this.Exists(plugin, key);

            if (dbType != type)
            {
                throw new InvalidCastException("Can't lookup type " + type.ToString() + " because it's registered as " + dbType.ToString() + " at " + key + "@" + plugin);
            }
            if (type == ConfigType.Custom)
            {
                throw new ArgumentException("Can not get type Custom!");
            }

            if (!exists)
            {
                lock (this.ConfigurationEntries)
                    if (this.ConfigurationEntries[plugin.ToLower()][key.ToLower()].Type != type)
                    {
                        throw new InvalidCastException();
                    }
                    else
                    {
                        return(this.ConfigurationEntries[plugin.ToLower()][key.ToLower()].DefaultValue);
                    }
            }

            plugin = Config.EscapeString(plugin.ToLower());
            key    = Config.EscapeString(key.ToLower());
            object result = null;

            try
            {
                using (IDbCommand command = this.Config.Connection.CreateCommand())
                {
                    command.CommandText = "SELECT Value FROM CORE_Settings WHERE Section = '" + plugin + "' AND Key = '" + key + "'";
                    IDataReader reader = command.ExecuteReader();
                    if (reader.Read())
                    {
                        switch (type)
                        {
                        case ConfigType.String:
                        case ConfigType.Username:
                        case ConfigType.Color:
                        case ConfigType.Password:
                            result = reader.GetString(0);
                            break;

                        case ConfigType.Integer:
                            result = (Int32)reader.GetInt64(0);
                            break;

                        case ConfigType.Boolean:
                            result = false;
                            if (reader.GetString(0).ToLower() == "true")
                            {
                                result = true;
                            }
                            break;

                        case ConfigType.Date:
                            result = TimeStamp.ToDateTime(reader.GetInt64(0));
                            break;

                        case ConfigType.Time:
                            result = new TimeSpan(reader.GetInt64(0));
                            break;

                        case ConfigType.Dimension:
                            result = (Server)Enum.Parse(typeof(Server), reader.GetString(0));
                            break;
                        }
                    }
                    reader.Close();
                }
            }
            catch { return(defaultValue); }
            return(result);
        }
Exemplo n.º 59
0
 public Task <ConfigEntity> GetByKeyWithLike(string key, ConfigType type = ConfigType.Custom)
 {
     return(Db.Find(m => m.Key.Contains(key) && m.Type == type).FirstAsync());
 }
Exemplo n.º 60
0
 public void SetConfigType(ConfigType type)
 {
     this.ConfigType = type;
 }