Esempio n. 1
0
        public FriendCollection(Dictionary <string, object> dict, IResourceService resourceService)
        {
            id      = dict.GetStringOrDefault("user_id");
            friends = new List <INetUser>();

            if (dict.ContainsKey("friends"))
            {
                Dictionary <string, object> dictFriends = dict["friends"] as Dictionary <string, object>;
                if (dictFriends != null)
                {
                    foreach (var kvp in dictFriends)
                    {
                        Dictionary <string, object> friend = kvp.Value as Dictionary <string, object>;
                        if (friend != null)
                        {
                            NetPlayer netPlayer = new NetPlayer(friend, true, resourceService);
                            if (!netPlayer.IsNull)
                            {
                                friends.Add(netPlayer);
                            }
                        }
                    }
                }
            }

            this.friends.Sort((f1, f2) => { return(f1.id.CompareTo(f2.id)); });
        }
Esempio n. 2
0
 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()));
        }
        public void GetStringOrDefault_Should_Return_The_Default_String_Value()
        {
            var source = new Dictionary <string, object>
            {
                ["stringKey"] = "valueString"
            };

            var result = source.GetStringOrDefault("stringKeyNotFound");

            Assert.AreEqual(result, null);
        }
        public void GetStringOrDefault_Should_Return_String_CultureInfo_Based()
        {
            var source = new Dictionary <string, object>
            {
                ["doubleKey"] = 16325.62901
            };


            var culture = CultureInfo.CreateSpecificCulture("de-DE");
            var result  = source.GetStringOrDefault("doubleKey", culture);

            Assert.AreEqual("16325,62901", result);
        }
Esempio n. 6
0
        public static InventoryItemType GetItemType(this Dictionary <string, object> dict, string key)
        {
            string strType = dict.GetStringOrDefault(key);

            if (string.IsNullOrEmpty(strType))
            {
                return(InventoryItemType.None);
            }
            InventoryItemType result;

            if (Enum.TryParse <InventoryItemType>(strType, out result))
            {
                return(result);
            }
            return(InventoryItemType.None);
        }
Esempio n. 7
0
        public NetGift(Dictionary <string, object> dict, IResourceService resource)
        {
            _id = dict.GetStringOrDefault("gift_id");

            string senderId     = dict.GetStringOrDefault("sender_id");
            string senderName   = dict.GetStringOrDefault("sender_name");
            string senderAvatar = dict.GetStringOrDefault("sender_avatar_id");
            int    senderLevel  = dict.GetIntOrDefault("sender_level");

            string receiverId     = dict.GetStringOrDefault("receiver_id");
            string receiverName   = dict.GetStringOrDefault("receiver_name");
            string receiverAvatar = dict.GetStringOrDefault("receiver_avatar_id");
            int    receiverLevel  = dict.GetIntOrDefault("receiver_level");

            InventoryItemType itemType = dict.GetItemType("item_type");
            string            itemId   = dict.GetStringOrDefault("item_id");

            ISender           sender   = new NetPlayer(senderId, senderName, senderAvatar, senderLevel, true);
            ISender           receiver = new NetPlayer(receiverId, receiverName, receiverAvatar, receiverLevel, true);
            InventoryItemData itemData = resource.GetInventoryItemData(itemType, itemId);

            gift = new Gift(sender, receiver, itemData);
        }
Esempio n. 8
0
File: Order.cs Progetto: abel/sinan
        public static Order CreateShipment(Dictionary<string, string> querise)
        {
            Order log = new Order();
            log.Created = DateTime.UtcNow;
            log.amt = int.Parse(querise.GetStringOrDefault("amt"));
            log.billno = querise.GetStringOrDefault("billno");
            log.openid = querise.GetStringOrDefault("openid");
            log.payitem = querise.GetStringOrDefault("payitem");
            log.version = querise.GetStringOrDefault("version") ?? "v3";

            int providetype;
            if (int.TryParse(querise.GetStringOrDefault("providetype"), out providetype))
            {
                log.providetype = providetype;
            }

            log.ppc = querise.GetStringOrDefault("pubacct_payamt_coins");
            log.sig = querise.GetStringOrDefault("sig");
            log.token = querise.GetStringOrDefault("token");

            long ts;
            if (long.TryParse(querise.GetStringOrDefault("ts"), out ts))
            {
                log.ts = ts;
            }

            string zone = querise.GetStringOrDefault("zoneid");
            if (!string.IsNullOrEmpty(zone))
            {
                if (zone[0] == 'S' || zone[0] == 's')
                {
                    log.zoneid = int.Parse(zone.Substring(1));
                }
                else
                {
                    log.zoneid = int.Parse(zone);
                }
            }
            return log;
        }
Esempio n. 9
0
 internal static void DeserializeBaseValues(IFilter filter, bool cacheDefault, Dictionary<string, object> fieldDict)
 {
     filter.Cache = fieldDict.GetBool(_CACHE, cacheDefault);
     filter.CacheKey = fieldDict.GetStringOrDefault(_CACHE_KEY);
     filter.FilterName = fieldDict.GetStringOrDefault(_FILTER_NAME);
 }
Esempio n. 10
0
 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);
 }
Esempio n. 11
0
        private static RangeQueryBase BuildRangeQuery(string fieldName, Dictionary<string, object> fieldDict)
        {
            object value = fieldDict.First(x => x.Key != QuerySerializer._BOOST).Value;

            RangeQueryBase query = null;

            if (value is Int32 || value is Int64)
            {
                query = new IntegerRangeQuery(fieldName,
                    fieldDict.GetInt64OrNull(_GREATER_THAN),
                    fieldDict.GetInt64OrNull(_LESS_THAN),
                    fieldDict.GetInt64OrNull(_GREATER_THAN_OR_EQUAL_TO),
                    fieldDict.GetInt64OrNull(_LESS_THAN_OR_EQUAL_TO));
            }
            else if (value is Double || value is float)
            {
                query = new DoubleRangeQuery(fieldName,
                    fieldDict.GetDoubleOrNull(_GREATER_THAN),
                    fieldDict.GetDoubleOrNull(_LESS_THAN),
                    fieldDict.GetDoubleOrNull(_GREATER_THAN_OR_EQUAL_TO),
                    fieldDict.GetDoubleOrNull(_LESS_THAN_OR_EQUAL_TO));
            }
            else
            {
                try
                {
                    DateTime.Parse(value.ToString());
                    query = new DateTimeRangeQuery(fieldName,
                        fieldDict.GetDateTimeOrNull(_GREATER_THAN),
                        fieldDict.GetDateTimeOrNull(_LESS_THAN),
                        fieldDict.GetDateTimeOrNull(_GREATER_THAN_OR_EQUAL_TO),
                        fieldDict.GetDateTimeOrNull(_LESS_THAN_OR_EQUAL_TO));
                }
                catch
                {
                    query = new StringRangeQuery(fieldName,
                        fieldDict.GetStringOrDefault(_GREATER_THAN),
                        fieldDict.GetStringOrDefault(_LESS_THAN),
                        fieldDict.GetStringOrDefault(_GREATER_THAN_OR_EQUAL_TO),
                        fieldDict.GetStringOrDefault(_LESS_THAN_OR_EQUAL_TO));
                }
            }

            query.QueryName = fieldDict.GetStringOrDefault(QuerySerializer._QUERY_NAME);

            return query;
        }
Esempio n. 12
0
        private FuzzyQueryBase BuildFuzzyQuery(string fieldName, Dictionary<string, object> fieldDict)
        {
            object value = fieldDict[_VALUE];
            object fuzziness = null;
            if (fieldDict.ContainsKey(_FUZZINESS))
                fuzziness = fieldDict[_FUZZINESS];

            FuzzyQueryBase query = null;
            if (IsDateTime(value))
            {
                if(fuzziness != null)
                    query = new FuzzyDateQuery(fieldName, DateTime.Parse(value.ToString()), new TimeValue(fuzziness.ToString()).TimeSpan);
                else
                    query = new FuzzyDateQuery(fieldName, DateTime.Parse(value.ToString()));
            }
            else if (IsNumeric(value))
            {
                bool isInteger = false;
                if (value is Int64 || value is Int32)
                    isInteger = true;

                if (fuzziness != null && isInteger)
                {
                    if (isInteger)
                        query = new FuzzyNumberQuery(fieldName, (Int64)value, (Int64)fuzziness);
                    else
                        query = new FuzzyNumberQuery(fieldName, (Double)value, (Double)fuzziness);
                }
                else
                {
                    if (isInteger)
                        query = new FuzzyNumberQuery(fieldName, (Int64)value);
                    else
                        query = new FuzzyNumberQuery(fieldName, (Double)value);
                }
            }
            else
            {
                if (fuzziness != null)
                    query = new FuzzyStringQuery(fieldName, value.ToString(), Int32.Parse(fuzziness.ToString()));
                else
                    query = new FuzzyStringQuery(fieldName, value.ToString());
            }

            query.Boost = fieldDict.GetDouble(QuerySerializer._BOOST, QuerySerializer._BOOST_DEFAULT);
            query.MaximumExpansions = fieldDict.GetInt32(_MAXIMUM_EXPANSIONS, _MAXIMUM_EXPANSIONS_DEFAULT);
            query.PrefixLength = fieldDict.GetInt32(_PREFIX_LENGTH, _PREFIX_LENGTH_DEFAULT);
            query.QueryName = fieldDict.GetStringOrDefault(QuerySerializer._QUERY_NAME);
            return query;
        }
Esempio n. 13
0
        private RangeBucket DeserializeRangeBucket(Dictionary<string, object> bucketDict)
        {
            RangeBucket bucket = new RangeBucket();
            if (bucketDict.ContainsKey(_GREATER_THAN))
                bucket.GreaterThan = bucketDict[_GREATER_THAN];
            if (bucketDict.ContainsKey(_LESS_THAN))
                bucket.LessThan = bucketDict[_LESS_THAN];
            if (bucketDict.ContainsKey(_GREATER_THAN_OR_EQUAL_TO))
                bucket.GreaterThanOrEqualTo = bucketDict[_GREATER_THAN_OR_EQUAL_TO];
            if (bucketDict.ContainsKey(_LESS_THAN_OR_EQUAL_TO))
                bucket.LessThanOrEqualTo = bucketDict[_LESS_THAN_OR_EQUAL_TO];

            bucket.Key = bucketDict.GetStringOrDefault(_RANGE_KEY);

            return bucket;
        }
Esempio n. 14
0
        private static RangeFilterBase BuildRangeFilter(string fieldName, Dictionary<string, object> fieldDict)
        {
            object value = fieldDict.First().Value;

            if (value is Int32 || value is Int64)
            {
                return new IntegerRangeFilter(fieldName,
                    fieldDict.GetInt64OrNull(_GREATER_THAN),
                    fieldDict.GetInt64OrNull(_LESS_THAN),
                    fieldDict.GetInt64OrNull(_GREATER_THAN_OR_EQUAL_TO),
                    fieldDict.GetInt64OrNull(_LESS_THAN_OR_EQUAL_TO));
            }

            if (value is Double || value is float)
            {
                return new DoubleRangeFilter(fieldName,
                    fieldDict.GetDoubleOrNull(_GREATER_THAN),
                    fieldDict.GetDoubleOrNull(_LESS_THAN),
                    fieldDict.GetDoubleOrNull(_GREATER_THAN_OR_EQUAL_TO),
                    fieldDict.GetDoubleOrNull(_LESS_THAN_OR_EQUAL_TO));
            }

            try
            {
                DateTime.Parse(value.ToString());
                return new DateTimeRangeFilter(fieldName,
                    fieldDict.GetDateTimeOrNull(_GREATER_THAN),
                    fieldDict.GetDateTimeOrNull(_LESS_THAN),
                    fieldDict.GetDateTimeOrNull(_GREATER_THAN_OR_EQUAL_TO),
                    fieldDict.GetDateTimeOrNull(_LESS_THAN_OR_EQUAL_TO));
            }
            catch
            {
                return new StringRangeFilter(fieldName,
                    fieldDict.GetStringOrDefault(_GREATER_THAN),
                    fieldDict.GetStringOrDefault(_LESS_THAN),
                    fieldDict.GetStringOrDefault(_GREATER_THAN_OR_EQUAL_TO),
                    fieldDict.GetStringOrDefault(_LESS_THAN_OR_EQUAL_TO));
            }
        }
Esempio n. 15
0
        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;
        }