public SendEncryptedCommand(Dictionary <string, object> info) { Type = "elector_encrypt_sign"; Encrypted = System.Numerics.BigInteger.Parse(info.GetString("encrypted")).ToByteArray(); EncryptedSigned = System.Numerics.BigInteger.Parse(info.GetString("signed")).ToByteArray(); EncryptionKey = info.GetDictionary("key"); }
public DirectionDescription(Dictionary <string, object> node) { Name = node.GetString("name"); Description = node.GetString("description"); Teacher = node.GetString("teacher"); Tags = node.GetStingArray("tags"); }
internal static IEnumerable<IAggregation> DeserializeSubAggregations(Dictionary<string, object> aggDict) { Dictionary<string, object> subAggsDict = null; if (aggDict.ContainsKey(BucketAggregationBase._SUB_AGGREGATIONS)) { subAggsDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(aggDict.GetString(_SUB_AGGREGATIONS)); } else if (aggDict.ContainsKey(BucketAggregationBase._SUB_AGGREGATIONS_ABBR)) { subAggsDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(aggDict.GetString(_SUB_AGGREGATIONS_ABBR)); } else return null; List<IAggregation> subAggregations = new List<IAggregation>(); AggregationTypeEnum aggType = AggregationTypeEnum.Average; foreach (KeyValuePair<string, object> aggKvp in subAggsDict) { Dictionary<string, object> aggTypeDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(aggKvp.Value.ToString()); aggType = AggregationTypeEnum.Find(aggTypeDict.First().Key); if(aggType == null) throw new Exception(aggTypeDict.First().Key + " is not a value aggregation type."); Dictionary<string, object> subAggDict = new Dictionary<string, object>(); subAggDict.Add(aggKvp.Key, aggKvp.Value); string subAggJson = JsonConvert.SerializeObject(subAggDict); subAggregations.Add(JsonConvert.DeserializeObject(subAggJson, aggType.ImplementationType) as IAggregation); } return subAggregations; }
/** * 校验请求结果 * * @param response 请求结果 * @return 如果请求结果正常,则返回Exception */ private void checkResponse(Dictionary <string, object> dic) { if (dic.ContainsKey("error") || dic.ContainsKey("error_description")) { throw new Exception($"{dic.GetString("error")}: {dic.GetString("error_description")}"); } }
/** * 校验请求结果 * * @param response 请求结果 * @return 如果请求结果正常,则返回JSONObject */ private void checkResponse(Dictionary <string, object> dic) { if (dic.ContainsKey("errcode") && dic.GetInt32("errcode") != 0) { throw new Exception($"errcode: {dic.GetString("errcode")}, errmsg: {dic.GetString("errmsg")}"); } }
/** * 校验请求结果 * * @param response 请求结果 * @return 如果请求结果正常,则返回Exception */ private void checkResponse(Dictionary <string, object> dic) { if (dic.ContainsKey("message") && dic.ContainsKey("name")) { throw new Exception($"{dic.GetString("getString")}, {dic.GetString("name")}"); } }
public void Spawn(Vector2Int location, Game2048ChessType chessType) { if (chessboardDic.ContainsKey(location) == false) { Debug.LogError("生成位置错误location : " + location.ToString()); return; } if (chessboardDic[location] != null) { Debug.LogError("生成位置错误 该位置有棋子location : " + location.ToString()); return; } Debug.Log("生成位置:" + location.ToString()); Debug.Log("生成值:" + ((int)chessType).ToString()); Game2048Chess chess = pool.Get <Game2048Chess>(); chess.Init(Game2048ChessType.Number_2); chessboardDic[location] = chess; RefreshPosition(); Debug.Log("棋盘状态"); Debug.Log(chessboardDic.GetString()); }
/** * 检查响应内容是否正确 * * @param object 请求响应内容 */ private void checkResponse(Dictionary <string, object> dic) { if (dic.ContainsKey("status") && "failure".Equals(dic.GetString("status"))) { throw new Exception($"{dic.GetString("message")}"); } }
public override void Read(Dictionary <string, object> data) { Name = data.GetString("Name"); Description = data.GetString("Description"); Type = data.GetInt32("Type"); TypeClass = data.GetString("TypeClass"); }
public SendValidatorBlindSignCommand(Dictionary <string, object> info) { Type = "elector_blind_sign"; Blinded = System.Numerics.BigInteger.Parse(info.GetString("blinded")).ToByteArray(); BlindedSigned = System.Numerics.BigInteger.Parse(info.GetString("blinded_signed")).ToByteArray(); Id = info.GetString("id"); }
public UserInfo(Dictionary <string, object> rawData, TokenInfo tokenInfo) { id = rawData.GetString("id"); username = rawData.GetString("username"); defaultOrganization = rawData.GetDictionary("extendedProperties")?.GetString("UNITY_DEFAULT_ORGANIZATION"); m_TokenInfo = tokenInfo; }
public BattlePassDescription(Dictionary <string, object> node) { Sprite = node.GetString("image"); Level = node.GetInt("lvl"); Requirement = node.GetString("requirement"); Reward = node.GetString("description"); IsTaken = node.GetBool("IsTaken"); }
public static void AddItem(IControllerContext context, Dictionary <string, object> parameters) { IProject project = getProject(context); string parent = parameters.GetString("Parent"), name = parameters.GetString("Name"), description = parameters.GetString("Description"); int type = parameters.GetInt32("Type"); IProjectItem item = ProjectManager.Manager.ProjectAddItem(project, parent, type, name, description); context.Response.Write(Json.Serialize(new { result = true, data = item }, getSerializeOptions())); }
private IpRangeBucket DeserializeRangeBucket(Dictionary<string, object> bucketDict) { IpRangeBucket bucket = new IpRangeBucket(); if (bucketDict.ContainsKey(_TO)) bucket.To = bucketDict.GetString(_TO); if (bucketDict.ContainsKey(_FROM)) bucket.From = bucketDict.GetString(_FROM); return bucket; }
/** * 校验响应结果 * * @param object 接口返回的结果 */ private void checkResponse(Dictionary <string, object> dic) { if (dic.ContainsKey("NSP_STATUS")) { throw new Exception(dic.GetString("error")); } if (dic.ContainsKey("error")) { throw new Exception(dic.GetString("sub_error") + ":" + dic.GetString("error_description")); } }
public PhotoModel FromDbItem(Dictionary <string, AttributeValue> input) { PhotoId photoId = input.TryGetValue(FieldMappings.Photo.PhotoId, out var photoIdValue) ? PhotoId.FromDbValue(photoIdValue.S) : (PhotoId)Guid.Empty; var result = new PhotoModel { CreatedTime = input.GetDateTimeOffset(FieldMappings.Photo.CreatedTime), PhotoId = photoId, ObjectKey = input.GetString(FieldMappings.Photo.ObjectKey), State = input.GetValue(FieldMappings.Photo.State, value => (PhotoState)Enum.Parse(typeof(PhotoState), value)), UserId = input.GetValue(FieldMappings.Photo.UserId, value => UserId.FromDbValue(value)), UserName = input.GetString(FieldMappings.Photo.UserName), LikeCount = input.GetInt32(FieldMappings.Photo.LikeCount), CommentCount = input.GetInt32(FieldMappings.Photo.CommentCount), Hashtags = input.GetList(FieldMappings.Photo.Hashtags, value => new HashtagModel { PhotoId = photoId, Hashtag = value }) }; if (input.TryGetValue(FieldMappings.Photo.RawText, out var rawCommentValue)) { result.RawText = rawCommentValue.S; } if (input.TryGetValue(FieldMappings.Photo.Score, out var scoreValue)) { result.Score = double.Parse(scoreValue.N); } if (input.TryGetValue(FieldMappings.Photo.Sizes, out var sizeValues)) { result.Sizes = sizeValues.L.Select(value => { int width; int height; if (!value.M.TryGetValue("Width", out var widthValue) || !int.TryParse(widthValue.S, out width)) { throw new Exception($"Failed to parse '{widthValue.S}' as a Size Width"); } if (!value.M.TryGetValue("Height", out var heightValue) || !int.TryParse(heightValue.S, out height)) { throw new Exception($"Failed to parse '{heightValue.S}' as a Size Height"); } return(new Size(width, height)); }); } return(result); }
public PhotoComment FromDbItem(Dictionary <string, AttributeValue> input) { return(new PhotoComment { UserId = input.GetValue(FieldMappings.PhotoComment.UserId, value => UserId.FromDbValue(value)), PhotoId = input.GetValue(FieldMappings.PhotoComment.PhotoId, value => PhotoId.FromDbValue(value)), UserName = input.GetString(FieldMappings.PhotoComment.UserName), CreatedTime = input.GetDateTimeOffset(FieldMappings.PhotoComment.CreatedTime), Text = input.GetString(FieldMappings.PhotoComment.Text) }); }
/** * 校验请求结果 * * @param response 请求结果 * @return 如果请求结果正常,则返回Exception */ private void checkResponse(Dictionary <string, object> dic) { string message = dic.GetString("message"); var data = dic.GetString("data").ParseObject(); int errorCode = data.GetInt32("error_code"); if ("error".Equals(message) || errorCode != 0) { throw new Exception(data.GetString("description")); } }
public byte[] BlindData(Dictionary <string, object> blindKey, Dictionary <string, object> signKey, byte[] data) { var r = BigInt.Parse(blindKey.GetString("r")); var e = BigInt.Parse(signKey.GetString("e")); var n = BigInt.Parse(signKey.GetString("n")); var multiplier = BigInt.Pow(r, (int)e); var m = new BigInt(data); var result = BigInt.ModPow(m * multiplier, 1, n); return(result.ToByteArray()); }
public SettingsModel FromDbItem(Dictionary <string, AttributeValue> input) { var result = new SettingsModel(); result.Domain = input.GetString(FieldMappings.Settings.Domain); result.CreatedTime = input.GetDateTimeOffset(FieldMappings.CreatedTime); result.Version = input.GetString(FieldMappings.Settings.Version); result.SettingObjectJson = input.GetString(FieldMappings.Settings.SettingObjectJson); return(result); }
public byte[] UnBlindData(Dictionary <string, object> blindKey, Dictionary <string, object> signKey, byte[] blindedData) { var r = BigInt.Parse(blindKey.GetString("r")); var e = BigInt.Parse(signKey.GetString("e")); var n = BigInt.Parse(signKey.GetString("n")); var inversedR = r.GetInversed(n); var m = new BigInt(blindedData); var result = BigInt.ModPow(m * inversedR, 1, n); return(result.ToByteArray()); }
public bool VerifyData(Dictionary <string, object> publicKey, byte[] data, byte[] signedData) { var e = BigInt.Parse(publicKey.GetString("e")); var n = BigInt.Parse(publicKey.GetString("n")); var s = new BigInt(signedData); var m = BigInt.ModPow(s, e, n); var result = m.ToByteArray(); return(result.SequenceEqual(data)); }
internal static FieldDataFilter Deserialize(Dictionary<string, object> fieldDict) { if (fieldDict == null || !fieldDict.Any()) return null; if (fieldDict.ContainsKey(_FREQUENCY)) { return new FieldDataFilter(fieldDict.GetString(_REGEX_PATTERN), Frequency.Deserialize(JsonConvert.DeserializeObject<Dictionary<string, object>>(fieldDict.GetString(_FREQUENCY)))); } return new FieldDataFilter(fieldDict.GetString(_REGEX_PATTERN)); }
public byte[] Decrypt(Dictionary <string, object> privateKey, byte[] data) { var d = BigInt.Parse(privateKey.GetString("d")); var n = BigInt.Parse(privateKey.GetString("n")); var c = new BigInt(data); var m = BigInt.ModPow(c, d, n); var result = m.ToByteArray(); return(result); }
public byte[] Encrypt(Dictionary <string, object> publicKey, byte[] data) { var e = BigInt.Parse(publicKey.GetString("e")); var n = BigInt.Parse(publicKey.GetString("n")); var m = new BigInt(data); var c = BigInt.ModPow(m, e, n); var result = c.ToByteArray(); return(result); }
/** * 校验请求结果 * * @param response 请求结果 * @return 如果请求结果正常,则返回Exception */ private void checkResponse(Dictionary <string, object> dic) { if (dic.Count == 0) { throw new Exception("请求所返回的数据为空!"); } if (!"0".Equals(dic.GetString("c"))) { throw new Exception($"{dic.GetString("m")}"); } }
public byte[] SignData(Dictionary <string, object> privateKey, byte[] data) { var d = BigInt.Parse(privateKey.GetString("d")); var n = BigInt.Parse(privateKey.GetString("n")); var m = new BigInt(data); var s = BigInt.ModPow(m, d, n); var result = s.ToByteArray(); return(result); }
public NetworkManager(Dictionary <string, object> mainConfig) { var validatorHost = mainConfig.GetString("validator_ip"); var validatorPort = mainConfig.GetInt("validator_port"); _validator = new TCPServer(validatorHost, validatorPort); var agencyHost = mainConfig.GetString("agency_ip"); var agencyPort = mainConfig.GetInt("agency_port"); _agency = new TCPServer(agencyHost, agencyPort); }
public static Order CreateFromJson(Dictionary <string, object> json, Asset amountAsset, Asset priceAsset) { return(new Order( json.GetString("id"), (OrderSide)Enum.Parse(typeof(OrderSide), json.GetString("type"), true), amountAsset.LongToAmount(json.GetLong("amount")), Asset.LongToPrice(amountAsset, priceAsset, json.GetLong("price")), json.GetDate("timestamp"), amountAsset.LongToAmount(json.GetLong("filled")), (OrderStatus)Enum.Parse(typeof(OrderStatus), json.GetString("status")), amountAsset, priceAsset)); }
private User CreateAndPopulateUser(Dictionary <string, object> props) { return(new User { Id = props.GetInteger("id"), Name = props.GetString("name"), RealName = props.GetString("real_name"), Language = props.GetString("language"), TimeZone = props.GetString("timezone"), AccessLevel = props.GetReference("access_level", _lookupCache.AccessLevel), Projects = props.GetReferences <ReferenceCollection, Reference>("projects", _lookupCache.Project), EmailAddress = props.GetString("email") }); }
protected TEntry CreateEntry(Dictionary <string, object> item) { var entry = new TEntry(); entry.MiningEngine = MiningEngine; entry.ServiceEntry = this; entry.AlgoName = item.GetString("algo"); var algo = MiningEngine.AlgorithmEntries.Single(o => o.Name == entry.AlgoName); entry.Name = algo.Display; entry.PriceId = item.GetString("priceid"); entry.Hashrate = algo.Hashrate; entry.Power = algo.Power; entry.Weight = _weight; entry.Folder = ProcessedSubstitutions(item.GetString("folder"), algo) ?? string.Empty; entry.Command = ProcessedSubstitutions(item.GetString("command"), algo); entry.Arguments = ProcessedSubstitutions(item.GetString("arguments"), algo) ?? string.Empty; if (item.ContainsKey("usewindow")) { entry.UseWindow = bool.Parse(item["usewindow"].ToString()); } if (!string.IsNullOrWhiteSpace(DonationAccount)) { entry.DonationFolder = ProcessedDonationSubstitutions(item.GetString("folder"), algo) ?? string.Empty; entry.DonationCommand = ProcessedDonationSubstitutions(item.GetString("command"), algo); entry.DonationArguments = ProcessedDonationSubstitutions(item.GetString("arguments"), algo) ?? string.Empty; } return(entry); }
public void Speak(string text, dynamic playDevice, bool isSync, float?volume) { var settings = _plugin.Settings.AiCloudTtsSettings; personTable.TryGetValue(settings.Person, out string person); var option = new Dictionary <string, string>() { { "speaker_id", person.ToString() }, { "volume", (settings.Volume * 0.1).ToString() }, { "speed", (settings.Speed * 0.1).ToString() }, { "pitch", (settings.Pitch * 0.1).ToString() }, }; // Calculate hash var wave = _plugin.Cache.GetOrCreateFile( this, text.Replace(Environment.NewLine, "+"), "wav", option.GetString(), async f => { var wave_origin = f.Replace(".wav", ".origin.wav"); string body = $"speaker_id={person}&text={WebUtility.UrlEncode(text)}&ext=wav&volume={settings.Volume * 0.1}&speed={settings.Speed * 0.1}&pitch={settings.Pitch * 0.1}&callback=callback"; string result = await DownLoadWaveManifest("https://cloud.ai-j.jp/demo/aitalk2webapi_nop.php", body, settings.Proxy); if (!string.IsNullOrWhiteSpace(result)) { var url = "https://" + result.Replace("callback({\"url\":\"\\/\\/", "").Replace("\"})", "").Replace("\\", ""); await DownloadWaveFile(url, wave_origin, settings.Proxy); } if (File.Exists(wave_origin)) { new DemoParser(_plugin).Run(wave_origin, f); } tasksMap.Remove(text + option.GetString()); _plugin.SoundPlayer.Play(f, playDevice, isSync, volume); if (File.Exists(wave_origin)) { File.Delete(wave_origin); } }); if (File.Exists(wave)) { _plugin.SoundPlayer.Play(wave, playDevice, isSync, volume); } }
private void ReadProductInfo(ConfigurationBuilder builder) { _iapMap = new Dictionary <string, string>(); List <object> productArr = PSDKMgr.Instance.LocalConfig.GetArray(new string[] { "billing", "iaps" }); if (productArr != null) { foreach (object productObj in productArr) { if (productObj.GetType() == typeof(Dictionary <string, object>)) { Dictionary <string, object> productDict = productObj as Dictionary <string, object>; string productTypeStr = productDict.GetString("type", ""); ProductType productType; if (TryParseProductType(productTypeStr, out productType)) { string iapId = productDict.GetString("iapId", ""); string itemId = productDict.GetString("id", ""); bool isNoAds = productDict.GetBool("noAds"); if (itemId.Length > 0 && iapId.Length > 0) { Debug.Log("Billing::ReadProductInfo:Adding Product - iapId = " + iapId + ", id = " + itemId + ", type = " + productTypeStr + ", noAds = " + isNoAds.ToString()); _iapMap.Add(itemId, iapId); if (isNoAds) { _noAdsIapIds += ";" + iapId; } #if AMAZON const string androidStore = AmazonApps.Name; #else const string androidStore = GooglePlay.Name; #endif Debug.Log("Billing::ReadProductInfo:" + androidStore + " selected"); string storeName = (Application.platform == RuntimePlatform.IPhonePlayer) ? AppleAppStore.Name : androidStore; var storeList = new List <string> { storeName }; string[] stores = storeList.ToArray(); builder.AddProduct(iapId, productType, new IDs { { iapId, stores } }); } } } } } }
internal static void DeserializeFacetInfo(FacetBase facet, Dictionary<string, object> facetDict) { if (facetDict.ContainsKey(_FACET_FILTER)) facet.FacetFilter = JsonConvert.DeserializeObject<IFilter>(facetDict.GetString(_FACET_FILTER)); facet.IsScopeGlobal = facetDict.GetBool(_GLOBAL, _GLOBAL_DEFAULT); facet.NestedObject = facetDict.GetStringOrDefault(_NESTED); facet.Size = facetDict.GetInt32(_SIZE, _SIZE_DEFAULT); }
internal static void Deserialize(DocumentPropertyBase prop, Dictionary<string, object> fieldDict) { if (!fieldDict.Any()) return; MappingBase.Deserialize(prop, fieldDict); prop.IncludeInAll = fieldDict.GetBool(_INCLUDE_IN_ALL, _INCLUDE_IN_ALL_DEFAULT); prop.IndexName = fieldDict.GetStringOrDefault(_INDEX_NAME); prop.PropertyType = PropertyTypeEnum.Find(fieldDict.GetString(_TYPE, _PROPERTY_TYPE_DEFAULT.ToString())); }
internal static void Deserialize(MappingBase mappingBase, Dictionary<string, object> fieldDict) { if (fieldDict == null || !fieldDict.Any()) return; IndexSettingEnum indexSetting = IndexSettingEnum.No; mappingBase.Index = IndexSettingEnum.Find(fieldDict.GetString(_INDEX_KEY, mappingBase._INDEX_DEFAULT.ToString())); StoreSettingEnum storeSetting = StoreSettingEnum.No; mappingBase.Store = fieldDict.GetBool(_STORE_KEY, mappingBase._STORE_DEFAULT); }
internal static void Deserialize(AnalyzerBase analyzer, Dictionary<string, object> fieldDict) { if (fieldDict == null || !fieldDict.Any()) return; analyzer.Version = fieldDict.GetDoubleOrNull(_VERSION); if (fieldDict.ContainsKey(_ALIASES)) { analyzer.Aliases = JsonConvert.DeserializeObject<IEnumerable<string>>(fieldDict.GetString(_ALIASES)); } }
internal static Norms Deserialize(Dictionary<string, object> fieldDict, bool isAnalyzed = true) { if (fieldDict == null || !fieldDict.ContainsKey(_NORMS)) return null; Norms norms = new Norms(); Dictionary<string, object> normsDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(fieldDict.GetString(_NORMS)); if (isAnalyzed) norms.IsEnabled = normsDict.GetBool(_IS_ENABLED, _IS_ENABLED_ANALYZED_DEFAULT); else norms.IsEnabled = normsDict.GetBool(_IS_ENABLED, _IS_ENABLED_NOT_ANALYZED_DEFAULT); norms.Loading = NormLoadingEnum.Find(normsDict.GetString(_LOADING, _LOADING_DEFAULT.ToString())); return norms; }
private void ReadFieldsDict(Dictionary<string, object> fieldsDict, MatchQueryBase matchQuery) { matchQuery.Analyzer = fieldsDict.GetStringOrDefault(_ANALYZER); matchQuery.CutOffFrequency = fieldsDict.GetDouble(_CUTOFF_FREQUENCY, _CUTOFF_FREQUENCY_DEFAULT); matchQuery.Fuzziness = fieldsDict.GetDouble(_FUZZINESS, _FUZZINESS_DEFAULT); matchQuery.IsLenient = fieldsDict.GetBool(_LENIENT, _LENIENT_DEFAULT); matchQuery.MaximumExpansions = fieldsDict.GetInt32OrNull(_MAX_EXPANSIONS); matchQuery.MinimumShouldMatch = fieldsDict.GetInt32(_MINIMUM_SHOULD_MATCH, _MINIMUM_SHOULD_MATCH_DEFAULT); matchQuery.Operator = OperatorEnum.Find(fieldsDict.GetString(_OPERATOR, _OPERATOR_DEFAULT.ToString())); matchQuery.PrefixLength = fieldsDict.GetInt32(_PREFIX_LENGTH, _PREFIX_LENGTH_DEFAULT); matchQuery.RewriteMethod = RewriteMethodsEnum.Find(fieldsDict.GetString(_REWRITE, "not a real object")); matchQuery.ZeroTerm = ZeroTermsEnum.Find(fieldsDict.GetString(_ZERO_TERMS_QUERY, _ZERO_TERMS_QUERY_DEFAULT.ToString())); matchQuery.QueryName = fieldsDict.GetStringOrDefault(QuerySerializer._QUERY_NAME); }
internal static DocumentMapping Deserialize(Dictionary<string, object> fieldDict) { DocumentMapping mapping = new DocumentMapping(); if (fieldDict.ContainsKey(_ALL)) mapping.All = JsonConvert.DeserializeObject<All>(fieldDict.GetString(_ALL)); if (fieldDict.ContainsKey(_ANALYZER)) mapping.Analyzer = JsonConvert.DeserializeObject<DocumentAnalyzer>(fieldDict.GetString(_ANALYZER)); if (fieldDict.ContainsKey(_ID)) mapping.Id = JsonConvert.DeserializeObject<DocumentIdentifier>(fieldDict.GetString(_ID)); if (fieldDict.ContainsKey(_INDEX)) mapping.Index = JsonConvert.DeserializeObject<DocumentIndex>(fieldDict.GetString(_INDEX)); if (fieldDict.ContainsKey(_PARENT)) mapping.Parent = JsonConvert.DeserializeObject<ParentType>(fieldDict.GetString(_PARENT)); if (fieldDict.ContainsKey(_ROUTING)) mapping.Routing = JsonConvert.DeserializeObject<DocumentRouting>(fieldDict.GetString(_ROUTING)); if (fieldDict.ContainsKey(_SIZE)) mapping.Size = JsonConvert.DeserializeObject<DocumentSize>(fieldDict.GetString(_SIZE)); if (fieldDict.ContainsKey(_SOURCE)) mapping.Source = JsonConvert.DeserializeObject<DocumentSource>(fieldDict.GetString(_SOURCE)); if (fieldDict.ContainsKey(_TIME_TO_LIVE)) mapping.TimeToLive = JsonConvert.DeserializeObject<DocumentTimeToLive>(fieldDict.GetString(_TIME_TO_LIVE)); if (fieldDict.ContainsKey(_TIMESTAMP)) mapping.Timestamp = JsonConvert.DeserializeObject<DocumentTimestamp>(fieldDict.GetString(_TIMESTAMP)); if (fieldDict.ContainsKey(_TYPE)) mapping.Type = JsonConvert.DeserializeObject<DocumentType>(fieldDict.GetString(_TYPE)); return mapping; }
internal static void Deserialize(ObjectProperty prop, Dictionary<string, object> fieldDict) { if (fieldDict == null || !fieldDict.Any()) return; if (fieldDict.ContainsKey(_COPY_TO)) { try { prop.CopyTo = JsonConvert.DeserializeObject<IEnumerable<string>>(fieldDict.GetString(_COPY_TO)); } catch { prop.CopyTo = new List<string>() { fieldDict.GetString(_COPY_TO) }; } } prop.Dynamic = DynamicSettingEnum.Find(fieldDict.GetString(_DYNAMIC, _DYNAMIC_DEFAULT.ToString())); prop.IncludeInAll = fieldDict.GetBool(_INCLUDE_IN_ALL, _INCLUDE_IN_ALL_DEFAULT); prop.IsEnabled = fieldDict.GetBool(_IS_ENABLED, _IS_ENABLED_DEFAULT); if (fieldDict.ContainsKey(_PROPERTIES)) { prop.Properties = JsonConvert.DeserializeObject<DocumentPropertyCollection>(fieldDict.GetString(_PROPERTIES)); } }
private GeoBoundingBoxFilter RetrieveBox(string fieldName, Dictionary<string, object> boxDict) { // maybe are are dealing with the vertices if (boxDict.Count() == 4) return GetBoxFromVertices(fieldName, boxDict); CoordinatePoint topLeft; CoordinatePoint bottomRight; if (boxDict.ContainsKey(_TOP_LEFT)) { topLeft = CoordinatePointSerializer.DeserializeCoordinatePoint(boxDict.GetString(_TOP_LEFT)); bottomRight = CoordinatePointSerializer.DeserializeCoordinatePoint(boxDict.GetString(_BOTTOM_RIGHT)); } else if (boxDict.ContainsKey(_TOP_RIGHT)) { CoordinatePoint topRight = CoordinatePointSerializer.DeserializeCoordinatePoint(boxDict.GetString(_TOP_RIGHT)); CoordinatePoint bottomLeft = CoordinatePointSerializer.DeserializeCoordinatePoint(boxDict.GetString(_BOTTOM_LEFT)); topLeft = new CoordinatePoint(topRight.Latitude, bottomLeft.Longitude); bottomRight = new CoordinatePoint(bottomLeft.Latitude, topRight.Longitude); } else { throw new Exception("No bounding box formed by current properties."); } return new GeoBoundingBoxFilter(fieldName, topLeft, bottomRight); }
internal static PropertyAnalyzer Deserialize(Dictionary<string, object> fieldDict) { if (fieldDict == null || !fieldDict.Any()) return null; PropertyAnalyzer propertyAnalyzer = null; if (fieldDict.ContainsKey(_ANALYZER)) { propertyAnalyzer = new PropertyAnalyzer(GetAnalyzer(fieldDict.GetString(_ANALYZER))); } else if (fieldDict.ContainsKey(_INDEX_ANALYZER)) { IAnalyzer searchAnalyzer = null; try { searchAnalyzer = GetAnalyzer(fieldDict.GetStringOrDefault(_SEARCH_ANALYZER)); } catch{} propertyAnalyzer = new PropertyAnalyzer( GetAnalyzer(fieldDict.GetString(_INDEX_ANALYZER)), searchAnalyzer); } return propertyAnalyzer; }
internal static void DeserializeHighlighterOptions(HighlighterOptions options, Dictionary<string, object> fieldDict) { if(fieldDict == null || !fieldDict.Any()) return; options.BoundaryCharacters = fieldDict.GetString(_BOUNDARY_CHARACTERS, _BOUNDARY_CHARACTERS_DEFAULT); options.BoundaryMaximumScan = fieldDict.GetInt32(_BOUNDARY_MAXIMUM_SCAN, _BOUNDARY_MAXIMUM_SCAN_DEFAULT); options.Encoder = EncoderTypeEnum.Find(fieldDict.GetString(_ENCODER, _ENCODER_DEFAULT.ToString())); options.FragmentSize = fieldDict.GetInt32(_FRAGMENT_SIZE, _FRAGMENT_SIZE_DEFAULT); options.NoMatchSize = fieldDict.GetInt32(_NO_MATCH_SIZE, _NO_MATCH_SIZE_DEFAULT); options.NumberOfFragments = fieldDict.GetInt32(_NUMBER_OF_FRAGMENTS, _NUMBER_OF_FRAGMENTS_DEFAULT); options.PhraseLimit = fieldDict.GetInt32(_PHRASE_LIMIT, _PHRASE_LIMIT_DEFAULT); if(fieldDict.ContainsKey(_POST_TAGS)) options.PostTags = JsonConvert.DeserializeObject<IEnumerable<string>>(fieldDict.GetString(_POST_TAGS)); if(fieldDict.ContainsKey(_PRE_TAGS)) options.PreTags = JsonConvert.DeserializeObject<IEnumerable<string>>(fieldDict.GetString(_PRE_TAGS)); options.RequireFieldMatch = fieldDict.GetBool(_REQUIRE_FIELD_MATCH, _REQUIRE_FIELD_MATCH_DEFAULT); options.TagsSchema = TagsSchemaEnum.Find(fieldDict.GetString(_TAGS_SCHEMA, _TAGS_SCHEMA_DEFAULT.ToString())); options.Type = HighlighterTypeEnum.Find(fieldDict.GetString(_HIGHLIGHTER_TYPE, _HIGHLIGHTER_TYPE_DEFAULT.ToString())); }
internal static void Deserialize(FieldProperty field, Dictionary<string, object> fieldDict) { MappingBase.Deserialize(field, fieldDict); field.IncludeInAll = fieldDict.GetBool(_INCLUDE_IN_ALL, _INCLUDE_IN_ALL_DEFAULT); field.Boost = fieldDict.GetDouble(_BOOST, _BOOST_DEFAULT); if (fieldDict.ContainsKey(_COPY_TO)) { try { field.CopyTo = JsonConvert.DeserializeObject<IEnumerable<string>>(fieldDict.GetString(_COPY_TO)); } catch { field.CopyTo = new List<string>(){ fieldDict.GetString(_COPY_TO) }; } } field.DocValuesFormat = DocValuesFormatEnum.Find(fieldDict.GetString(_DOC_VALUES_FORMAT, _DOC_VALUES_FORMAT_DEFAULT.ToString())); if(fieldDict.ContainsKey(_FIELD_DATA)) { field.FieldData = FieldDataFilter.Deserialize(JsonConvert.DeserializeObject<Dictionary<string, object>>(fieldDict.GetString(_FIELD_DATA))); } if(fieldDict.ContainsKey(_FIELDS)) { field.Fields = JsonConvert.DeserializeObject<DocumentPropertyCollection>(fieldDict.GetString(_FIELDS)); } field.IndexName = fieldDict.GetString(_INDEX_NAME, field.Name); if(fieldDict.ContainsKey(_NULL_VALUE)) field.NullValue = fieldDict[_NULL_VALUE]; field.PostingsFormat = PostingFormatEnum.Find(fieldDict.GetString(_POSTINGS_FORMAT, _POSTINGS_FORMAT_DEFAULT.ToString())); field.Similarity = SimilarityAlgorithmEnum.Find(fieldDict.GetString(_SIMILARITY, _SIMILARITY_DEFAULT.ToString())); }