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()));
}
