Ejemplo n.º 1
0
        public static void ThrowOnErrorResponse(this JsonValue jsonValue)
        {
            if (jsonValue.ContainsKey("error")) //pas error
            {
                throw new CDOException(jsonValue.Get("error"), jsonValue.Get("error_description"))
                      {
                          Scope = jsonValue.Get("scope")
                      };
            }

            if (jsonValue.ContainsKey("_errors")) //progress error
            {
                string code    = "";
                string message = jsonValue.Get("_retVal");

                var errors = (JsonArray)jsonValue.Get("_errors");
                foreach (var error in errors)
                {
                    code = error.Get("_errorNum").ToString();
                    if (string.IsNullOrEmpty(message))
                    {
                        message = error.Get("_errorMsg");
                    }
                    break;
                }

                throw new CDOException(code, message);
            }
        }
Ejemplo n.º 2
0
        static void Main(string[] args)
        {
            string    jsonString = "{\"a\": 1,\"b\": \"z\",\"c\":[{\"Value\": 1}, {\"Value\": 2}]}";
            JsonValue json       = JsonValue.Parse(jsonString);

            // int test
            if (json.ContainsKey("a"))
            {
                int a = json["a"];     // type already set to int
                Console.WriteLine(a);
            }
            // string test
            if (json.ContainsKey("b"))
            {
                string b = json["b"];      // type already set to string
                Console.WriteLine(b);
            }
            // object array test
            if (json.ContainsKey("c") && json["c"].JsonType == JsonType.Array)
            {
                foreach (JsonValue j in json["c"])
                {
                    Console.WriteLine(j["Value"].ToString());
                }
            }
            Console.WriteLine();
            Console.Write("Press any key to exit.");
            Console.ReadKey();
        }
Ejemplo n.º 3
0
        public List <Election> ParseElectionJson(JsonValue data)
        {
            elections = new List <Election>();
            if (!data.ContainsKey("error"))
            {
                JsonValue firstElection = data["election"];
                elections.Add(new Election {
                    id = firstElection["id"], name = firstElection["name"], date = firstElection["electionDay"]
                });


                if (data.ContainsKey("otherElections"))
                {
                    JsonArray upcomingElections = (JsonArray)data["otherElections"];

                    for (int i = 0; i < upcomingElections.Count; i++)
                    {
                        var current = upcomingElections[i];
                        elections.Add(new Election {
                            id = current["id"], name = current["name"], date = current["electionDay"]
                        });
                    }
                }
            }

            return(elections);
        }
Ejemplo n.º 4
0
        private void _configureDialog(JsonValue json, JsonObject valuesJson)
        {
            if (json.ContainsKey(Constants.Grouped))
            {
                Style = bool.Parse(json[Constants.Grouped].ToString()) ? UITableViewStyle.Grouped : UITableViewStyle.Plain;
            }
            if (json.ContainsKey(Constants.Title))
            {
                Title = json[Constants.Title];
            }

            if (json.ContainsKey(Constants.DataRoot))
            {
                DataRootName = json[Constants.DataRoot];
            }

            if (json.ContainsKey(Constants.RightBarItem))
            {
                NavigationItem.RightBarButtonItem = _createButtonItemFor(Constants.RightBarItem, json, valuesJson);
            }
            if (json.ContainsKey(Constants.LeftBarItem))
            {
                NavigationItem.LeftBarButtonItem = _createButtonItemFor(Constants.LeftBarItem, json, valuesJson);
            }
        }
Ejemplo n.º 5
0
 public ListResponse(JsonValue json)
 {
     if (json != null)
     {
         BuildNumber = json["build"];
         if (json.ContainsKey("torrentc"))
         {
             CacheID = json["torrentc"];
         }
         if (json.ContainsKey("torrents"))
         {
             Torrents = ((JsonArray)json["torrents"])
                        .Select(j => new Torrent(j))
                        .ToDictionary(t => t.ID);
         }
         if (json.ContainsKey("torrentp"))
         {
             ChangedTorrents = ((JsonArray)json["torrentp"])
                               .Select(j => new Torrent(j))
                               .ToArray();
         }
         if (json.ContainsKey("torrentm"))
         {
             RemovedTorrents = ((JsonArray)json["torrentm"])
                               .Select(j => new Torrent(j))
                               .ToArray();
         }
     }
 }
Ejemplo n.º 6
0
        private async Task <int> EventHandling(DataBaseWrapper db, JsonValue result)
        {
            if (result.ContainsKey("events"))
            {
                JsonArray arr = (JsonArray)result ["events"];
                foreach (JsonValue v in arr)
                {
                    var e = new Event()
                    {
                        type   = v ["type"],
                        msg    = v ["msg"],
                        nick   = v ["nick"],
                        text   = v ["text"],
                        time   = v ["time"],
                        author = v ["author"]
                    };
                    db.Insert(e);
                }

                if (backgroundService != null)
                {
                    await backgroundService.UpdateNotifications();
                }
            }
            if (result.ContainsKey("onLoginError"))
            {
                return(1);
            }
            return(0);
        }
Ejemplo n.º 7
0
        public static ResultForRoot FromJson(JsonValue json)
        {
            var result = new ResultForRoot(
                RootPosition.FromJson(json["position"])
                );

            foreach (Select select in SelectHelper.Values)
            {
                var selectStr = select.Stringify();
                if (json.ContainsKey(selectStr))
                {
                    result.ResultsBySelect.Add(select, SelectResult.FromJson(json[selectStr]));
                }
            }

            if (json.ContainsKey("retractions"))
            {
                foreach (KeyValuePair <string, JsonValue> entry in json["retractions"])
                {
                    var entries = SegregatedEntries.FromJson(entry.Value);
                    result.Retractions.Add(entry.Key, entries);
                }
            }

            return(result);
        }
Ejemplo n.º 8
0
        public static JsonValue GetJsonValue <T>(this JsonValue json, Expression <Func <T> > expression)
        {
            if (json == null)
            {
                return(null);
            }
            MemberExpression body = (MemberExpression)expression.Body;

            string name = null;

            if (!GetNameFromAttribute(body.Member, ref name))
            {
                name = GetJsonNamingConvention(body.Member.Name);
            }

            var result = json.ContainsKey(name) ? json[name] : null;

            if (result == null)
            {
                if (Debugger.IsAttached && !json.ContainsKey(name))
                {
                    throw new ArgumentOutOfRangeException("could not find jsonValue: " + name);
                }
                return(null);
            }
            if (result.JsonType == JsonType.Number || result.JsonType == JsonType.Boolean)
            {
                return(result.ToString());
            }
            return(result);
        }
        public CardSetFile ParseRawJsonFileLocation(string locationUrl)
        {
            if (string.IsNullOrEmpty(locationUrl))
            {
                throw new ArgumentNullException("locationUrl");
            }
            JsonValue jsonLocationUrl = null;

            try
            {
                jsonLocationUrl = JsonValue.Parse(locationUrl);
            }
            catch (ArgumentException ex)
            {
                _logger.LogError(ex, "Exception thrown in JsonParsingManager.ParseRawJsonFileLocation method.");
                throw new FormatException("locationUrl was not in JSON format.", ex);
            }
            CardSetFile cardSetFile = JsonConvert.DeserializeObject <CardSetFile>(locationUrl);
            string      cdnRootKey  = "cdn_root";
            string      dateKey     = "expire_time";
            string      urlKey      = "url";

            if (!jsonLocationUrl.ContainsKey(cdnRootKey) ||
                !jsonLocationUrl.ContainsKey(dateKey) ||
                !jsonLocationUrl.ContainsKey(urlKey))
            {
                FormatException ex = new FormatException("locationUrl was in JSON format, but did not have the correct keys.");
                _logger.LogError(ex, "Exception thrown in JsonParsingManager.ParseRawJsonFileLocation method.");
                throw ex;
            }
            return(cardSetFile);
        }
Ejemplo n.º 10
0
        public JsonValue SendMessage(JsonValue message)
        {
            string    origin;
            string    destination;
            JsonValue json;

            if (message.ContainsKey("persist") && (message["persist"].Value is Boolean) && ((bool)message["persist"] == false))
            {
                json = new JsonObject();
                string type = "message";
                if (message.ContainsKey("type"))
                {
                    type = (string)message["type"].Value;
                }
                origin      = (string)message["origin"].Value;
                destination = (string)message["destination"].Value;
                string content = null;
                if (message.ContainsKey("content"))
                {
                    content = message["content"];
                }
                json["type"]        = type;
                json["origin"]      = origin;
                json["destination"] = destination;
                json["content"]     = content;
                json["persist"]     = false;
            }
            else
            {
                lock (dbcon) {
                    using (IDbTransaction transaction = dbcon.BeginTransaction()) {
                        long id = SendMessage(dbcon, transaction, message);
                        json = GetMessage(dbcon, transaction, id);
                        transaction.Commit();
                    }
                }
                origin      = (string)json["origin"];
                destination = (string)json["destination"];
            }
            // signal the created message to the watched users
            JsonValue messageJson = new JsonObject();

            messageJson["event"]   = "messagecreated";
            messageJson["message"] = json;
            string jsonString = messageJson.ToString();

            lock (instanceLock) {
                if (clients.ContainsKey(origin))
                {
                    clients[origin].Broadcast(jsonString);
                }
                if (clients.ContainsKey(destination))
                {
                    clients[destination].Broadcast(jsonString);
                }
            }
            RaisesMessageCreated(json);
            return(json);
        }
Ejemplo n.º 11
0
        public void InvalidPropertyTest()
        {
            JsonValue target = AnyInstance.AnyJsonPrimitive;

            Assert.IsTrue(target.Count == 0);
            Assert.IsFalse(target.ContainsKey(string.Empty));
            Assert.IsFalse(target.ContainsKey(AnyInstance.AnyString));
        }
Ejemplo n.º 12
0
 public static Entry FromJson(JsonValue json)
 {
     return(new Entry(
                json["count"],
                json.ContainsKey("first_game") ? Optional <GameHeader> .Create(GameHeader.FromJson(json["first_game"])) : Optional <GameHeader> .CreateEmpty(),
                json.ContainsKey("last_game") ? Optional <GameHeader> .Create(GameHeader.FromJson(json["last_game"])) : Optional <GameHeader> .CreateEmpty(),
                json.ContainsKey("elo_diff") ? Optional <long> .Create(json["elo_diff"]) : Optional <long> .CreateEmpty()
                ));
 }
Ejemplo n.º 13
0
        public void PropertiesTest()
        {
            JsonValue target = AnyInstance.DefaultJsonValue;

            Assert.AreEqual(JsonType.Default, target.JsonType);
            Assert.AreEqual(0, target.Count);
            Assert.AreEqual(false, target.ContainsKey("hello"));
            Assert.AreEqual(false, target.ContainsKey(string.Empty));
        }
Ejemplo n.º 14
0
 void IClassifyObjectProcessor <JsonValue> .AfterSerialize(JsonValue element)
 {
     if (element is JsonDict && element.ContainsKey("Published") && element["Published"].GetStringSafe()?.EndsWith("Z") == true)
     {
         element["Published"] = element["Published"].GetString().Apply(s => s.Remove(s.Length - 1));
     }
     if (Type != KtaneModuleType.Regular && element is JsonDict && element.ContainsKey("Souvenir"))
     {
         element.Remove("Souvenir");
     }
 }
Ejemplo n.º 15
0
        /// <summary><para>Recursive funhouse of applying rules different ways depending on how they are described.
        /// This figures out how a rule should be applied. Rules are described in data as <paramref name="thing"/>. </para>
        /// <para>Applying an array causes every element of the array to be applied.</para>
        /// <para>Applying an object causes a 'key' of the object to be selected using WeightedChoose, then the key is applied.</para>
        /// <para>Applying a string causes us to search for the next rule named by the string, in the current <paramref name="rule"/>,
        ///	or if it can't be found there, in the <see cref="ruleset"/>. </para>
        ///	<para>Regardless of what is selected, the change in rules is recorded in the <see cref="State.genHistory"/></para></summary>
        /// <param name="state"> Current generator state </param>
        /// <param name="thing"> The thing we are trying to apply </param>
        /// <param name="rule"> The rule we are currently in (so we can find nested rules) </param>
        private void Apply(State state, JsonValue thing, JsonObject rule)
        {
            string path = state.lastHistory["path"].stringVal;

            // Rules eventually are told to us by strings describing them.
            if (thing.isString)
            {
                Console.WriteLine($"Applying String rule at {path} => {thing.stringVal}");
                var nextRule = FindRule(rule, thing.stringVal);
                if (nextRule is JsonObject)
                {
                    ApplyRule(state, nextRule as JsonObject, state.lastHistory);
                }
            }

            // May have arrays to describe a sequence of rules to apply
            if (thing.isArray)
            {
                Console.WriteLine($"Applying Array rule at {path} => {thing.ToString()}");
                foreach (var val in (thing as JsonArray))
                {
                    if (val.isString)
                    {
                        // If we're at a string, add it then apply it, since the next Apply will invoke a rule.
                        state.PushHistory(val.stringVal);
                    }
                    Apply(state, val, rule);
                    if (val.isString)
                    {
                        state.PopHistory();
                    }
                }
            }
            // If we're in an object, we need to make a decision of what name to apply,
            // as well as other things.
            if (thing.isObject)
            {
                if (thing.ContainsKey("repeat") && thing.ContainsKey("rule"))
                {
                    // Meta Object: Contains instruction to repeat something multiple times...
                    RepeatedApply(state, thing, rule, path);

                    // todo later: support other meta-applications with objects describing them...
                }
                else
                {
                    string chosen = state.WeightedChoose(thing as JsonObject);
                    Console.WriteLine($"Applying Weighted Choice rule at {path} => {chosen}");
                    state.PushHistory(chosen);
                    Apply(state, chosen, rule);
                    state.PopHistory();
                }
            }
        }
Ejemplo n.º 16
0
        public void SimpleContactJsonString(string firstName, string lastName, string email, string username, string department, string accountID)
        {
            string    json    = Contact.Create(firstName, lastName, email, username, department, accountID).ToString();
            JsonValue recover = JsonValue.Parse(json);

            Assert.Equal(6, recover.Count);
            Assert.True(recover.ContainsKey("firstname"));
            Assert.True(recover.ContainsKey("lastname"));
            Assert.True(recover.ContainsKey("emailaddress1"));
            Assert.True(recover.ContainsKey("new_username"));
            Assert.Equal($"/accounts({testGuid})", recover["*****@*****.**"]);
        }
Ejemplo n.º 17
0
        public string ParseElectionInfoJson(JsonValue data)
        {
            string response = "";

            if (data.ContainsKey("election"))
            {
                JsonValue election = data["election"];
                response = response + election["name"] + "\n" + election["electionDay"] + "\n";
            }
            if (data.ContainsKey("pollingLocations"))
            {
                JsonArray pollingLocations = (JsonArray)data["pollingLocations"];
                for (int i = 0; i < pollingLocations.Count; i++)
                {
                    JsonValue current = pollingLocations[i];
                    JsonValue address = current["address"];
                    response = address.ContainsKey("locationName") ? response + address["locationName"] + "\n" : response;
                    response = address.ContainsKey("line1") ? response + address["line1"] : response;
                    response = address.ContainsKey("line2") ? response + "\n" + address["line2"] : response;
                    response = address.ContainsKey("line3") ? response + "\n" + address["line3"] : response;
                    response = address.ContainsKey("city") ? response + "\n" + address["city"] : response;
                    response = address.ContainsKey("state") ? response + " " + address["state"] : response;
                    response = address.ContainsKey("zip") ? response + ", " + address["zip"] + "\n" : response;

                    response = current.ContainsKey("notes") ? response + current["notes"] + "\n": response;
                    response = current.ContainsKey("pollingHours") ? response + "Polling Hours:\n" + current["pollingHours"] + "\n\n" : response;
                }
            }
            if (data.ContainsKey("contests"))
            {
                JsonArray contests = (JsonArray)data["contests"];
                for (int i = 0; i < contests.Count; i++)
                {
                    JsonValue current = contests[i];
                    response = current.ContainsKey("office") ? response + "Contested Positions\n\n" + current["office"] + "\n\n" : response;
                    if (current.ContainsKey("candidates"))
                    {
                        response = response + "candidates\n\n";
                        JsonArray candidates = (JsonArray)current["candidates"];
                        for (int i2 = 0; i2 < candidates.Count; i2++)
                        {
                            JsonValue currentCand = candidates[i2];
                            response = currentCand.ContainsKey("name") ? response + currentCand["name"] + "\n" : response;
                            response = currentCand.ContainsKey("party") ? response + currentCand["party"] + "\n" : response;
                            response = currentCand.ContainsKey("phone") ? response + "phone #: " + currentCand["phone"] + "\n" : response;
                            response = currentCand.ContainsKey("email") ? response + currentCand["email"] + "\n\n" : response;
                        }
                    }
                }
            }

            return(response);
        }
Ejemplo n.º 18
0
 public static RootPosition FromJson(JsonValue json)
 {
     return(new RootPosition(
                json["fen"],
                json.ContainsKey("move") ? Optional <string> .Create(json["move"]) : Optional <string> .CreateEmpty()
                ));
 }
Ejemplo n.º 19
0
 internal Parser(JsonValue json)
 {
     _sourceparser = json;
     MissingTokens = json.ContainsKey("missing_tokens")
                         ? new HashSet <string>(json["missing_tokens"].Select(x => (string)x))
                         : new HashSet <string>();
 }
Ejemplo n.º 20
0
        public static async Task <List <ListItem> > GetListItems(string listName, string select, string expand, int top, string filter, string orderBy)
        {
            List <ListItem> listItems = new List <ListItem>();

            try
            {
                string requestUrl = string.Format("{0}/GetByTitle('{1}')/Items", Url, listName);
                if (!string.IsNullOrEmpty(select))
                {
                    requestUrl += string.Format("?$select={0}", select);
                }
                if (!string.IsNullOrEmpty(expand))
                {
                    requestUrl += string.Format("&$expand={0}", expand);
                }
                if (top > 0)
                {
                    requestUrl += string.Format("&$top={0}", top);
                }
                if (!string.IsNullOrEmpty(filter))
                {
                    requestUrl += string.Format("&$filter={0}", filter.Replace(" ", "%20"));
                }
                if (!string.IsNullOrEmpty(orderBy))
                {
                    requestUrl += string.Format("&$orderby={0}", orderBy.Replace(" ", "%20"));
                }

                HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(requestUrl);
                request.Method = "GET";
                request.Accept = "application/json; odata=verbose";
                request.Headers.Add("Authorization", "Bearer " + App.Token);

                using (HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse)
                {
                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        using (StreamReader stream = new StreamReader(response.GetResponseStream()))
                        {
                            string content = await stream.ReadToEndAsync();

                            JsonValue jsonValue = JsonValue.Parse(content);
                            if (jsonValue.ContainsKey("d") && jsonValue["d"].ContainsKey("results"))
                            {
                                for (int i = 0; i < jsonValue["d"]["results"].Count; i++)
                                {
                                    listItems.Add(new ListItem(jsonValue["d"]["results"][i]));
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception)
            {
                listItems = new List <ListItem>();
            }

            return(listItems);
        }
Ejemplo n.º 21
0
        public RemoteLocationManager(string name, string className, string path, ulong internalId, ulong parentInternalId, JsonValue objectDef) :
            base(name, className, path, internalId, parentInternalId)
        {
            if (!objectDef.ContainsKey("mismatches"))
            {
                return;
            }

            var mismatches = objectDef["mismatches"];

            mMismatches = new LocationMismatch[mismatches.Count];

            int index = 0;

            foreach (JsonValue item in mismatches)
            {
                var remoteDecoder = (RemoteDecoder)RemoteObjectManager.LoadObject(item["decoder"]);
                var reason        = item["reason"];

                String mappedLocation = item.ContainsKey("location") ? item["location"] : null;

                var mismatch = new LocationMismatch(remoteDecoder, reason, mappedLocation);
                mMismatches[index++] = mismatch;
            }
        }
Ejemplo n.º 22
0
        public RemoteLocation(string name, string className, string path, ulong internalId, ulong parentInternalId, JsonValue data) :
            base(name, className, path, internalId, parentInternalId)
        {
            mBeginAddress = data["begin"];
            mEndAddress   = data["end"];

            if (!data.ContainsKey("decoders"))
            {
                return;
            }

            var decoders = data["decoders"];
            var count    = decoders.Count;

            mRemoteDecoders = new RemoteDecoder[count];

            for (int i = 0; i < count; ++i)
            {
                var decInfo = decoders[i];
                if (decInfo == null)
                {
                    continue;
                }

                var remoteObject = RemoteObjectManager.LoadObject(decInfo);

                mRemoteDecoders[i] = remoteObject as RemoteDecoder;
            }
        }
Ejemplo n.º 23
0
    private static string getSessionName(string filePath, int sessionId)
    {
        Result information = getImporterInformation(filePath);

        if (information.success == false)
        {
            // This shouldn't happen, other getImporterInformation is used in different ways.
            LogB.Information("chronojumpImporter::getSessionName failed. Output:" + information.output + "Error:" + information.error);
            return("UNKNOWN");
        }
        else
        {
            JsonValue json = JsonValue.Parse(information.output);

            if (!json.ContainsKey("sessions"))
            {
                LogB.Information("Trying to import a session but sessions doesn't exist. Output:" + information.output);
                return("UNKNOWN");
            }

            foreach (JsonValue session in json["sessions"])
            {
                if (session.ContainsKey("uniqueID") && session ["uniqueID"] == sessionId)
                {
                    return(JsonUtils.valueOrDefault(session, "name", "UNKNOWN"));
                }
            }
            LogB.Information("Trying to import a session that we can't find the name. Output:" + information.output);
            return("UNKNOWN");
        }
    }
Ejemplo n.º 24
0
		static string GetString (JsonValue obj, string key)
		{
			if (obj.ContainsKey (key))
				if (obj [key].JsonType == JsonType.String)
					return (string) obj [key];
			return null;
		}
        public static Offer FromJson(JsonValue item)
        {
            if (item != null && item.ContainsKey("id"))
            {
                Offer offer = new Offer();
                var   json  = item;
                offer.Id           = json.GetJsonValue(() => offer.Id);
                offer.SelectStores = json.GetJsonValue(() => offer.SelectStores);
                offer.Promoted     = json.GetJsonValue(() => offer.Promoted);
                offer.Heading      = json.GetJsonValue(() => offer.Heading);
                offer.Description  = json.GetJsonValue(() => offer.Description);
                offer.Price        = json.GetJsonValue(() => offer.Price);
                offer.Preprice     = json.GetJsonValue(() => offer.Preprice);
                offer.Images       = Images.FromJson(json);
                offer.Url          = json.GetJsonValue(() => offer.Url);
                offer.RunFrom      = json.GetJsonValue(() => offer.RunFrom);
                offer.RunTill      = json.GetJsonValue(() => offer.RunTill);
                offer.Dealer       = Dealer.FromJson(json);

                //offer.Timespan = Timespan.FromJson(json.GetJsonValue(() => offer.Timespan));

                offer.Catalog = CatalogIndex.FromJson(json);
                offer.Store   = Store.FromJson(json);


                return(offer);
            }
            return(null);
        }
Ejemplo n.º 26
0
    public static bool ScanState(DirectoryInfo rootPath, string stateFileName, out string encryptKey)
    {
        FileInfo fi = new FileInfo(Path.Combine(rootPath.FullName, stateFileName));

        if (!fi.Exists)
        {
            encryptKey = null;
            return(false);
        }

        using (StreamReader sr = fi.OpenText())
        {
            string    json  = sr.ReadToEnd();
            JsonValue state = JsonValue.Parse(json);
            if (!state.ContainsKey("os_crypt"))
            {
                encryptKey = null;
                return(false);
            }

            JsonValue osCrypt = state["os_crypt"];
            if (!osCrypt.ContainsKey("encrypted_key"))
            {
                encryptKey = null;
                return(false);
            }

            encryptKey = osCrypt["encrypted_key"];
            return(true);
        }
    }
Ejemplo n.º 27
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="capabilitiesResult"></param>
        /// <returns></returns>
        public static StationsData ExtractStationData(string capabilitiesResult)
        {
            JsonValue    values       = JsonValue.Parse(capabilitiesResult);
            StationsData stationsData = new StationsData();

            if (values.ContainsKey("contents"))
            {
                var contents = values["contents"];
                for (int i = 0; i < contents.Count; i++)
                {
                    var entry      = contents[i];
                    var identifier = entry["identifier"].ToString().Trim(new char[] { '"' });
                    var property   = identifier.Split('.')[0];
                    var station    = identifier.Split('@')[1];

                    if (stationsData.HasStation(station))
                    {
                        stationsData.AddCapabilityToExistingStation(station, property);
                    }
                    else
                    {
                        if (entry.ContainsKey("observedArea"))
                        {
                            var location  = entry["observedArea"]["lowerLeft"];
                            var longitude = location[1];
                            var latitude  = location[0];
                            stationsData.AddNewStation(station, latitude, longitude, property);
                        }
                    }
                }
            }

            Console.WriteLine(stationsData);
            return(stationsData);
        }
Ejemplo n.º 28
0
 /// <summary>
 /// Get timestamp_ms field or pseudo timestamp string.
 /// </summary>
 /// <param name="graph">json object graph</param>
 /// <returns>timestamp code(millisecond)</returns>
 internal static string GetTimestamp(JsonValue graph)
 {
     return(graph.ContainsKey("timestamp_ms")
         ? graph["timestamp_ms"].AsString()
         : ((long)(DateTime.Now.ToUniversalTime() - StreamMessage.SerialTimeStandard)
            .TotalMilliseconds).ToString());
 }
Ejemplo n.º 29
0
        internal static void OnAuthResponse(IAsyncResult rs)
        {
            NetworkRequest      networkRequest  = rs.AsyncState as NetworkRequest;
            NetworkResponse     networkResponse = networkRequest.EndGetResponse(rs);
            NetworkStreamReader streamReader    = networkResponse.GetStreamReader();
            string text = streamReader.ReadToEnd();

            if (text.Length > 0)
            {
                JsonValue jsonValue = JsonValue.Parse(text);
                if (jsonValue.ContainsKey("b"))
                {
                    Network.serverTicket = (string)jsonValue.GetValue("b").GetValue("w");
                    Network.serverStatus = NetworkState.NetworkServerReady;
                }
                else
                {
                    Network.serverStatus = NetworkState.NetworkServerFailed;
                }
            }
            else
            {
                Network.serverStatus = NetworkState.NetworkServerFailed;
            }
        }
Ejemplo n.º 30
0
        public async Task <bool> TryToLogin(string username, string password)
        {
            // Create an HTTP web request using the URL:
            string         url     = "http://tojejedno.scrilab.sk/mina/SharePoint/api/login.php?username="******"&password="******"application/json";
            request.Method      = "GET";

            // Send the request to the server and wait for the response:
            using (WebResponse response = await request.GetResponseAsync())
            {
                // Get a stream representation of the HTTP web response:
                using (Stream stream = response.GetResponseStream())
                {
                    // Use this stream to build a JSON document object:
                    JsonValue jsonDoc = await Task.Run(() => JsonObject.Load(stream));

                    if (jsonDoc.ContainsKey("result"))
                    {
                        string res = jsonDoc["result"];
                        if (res.Equals("OK"))
                        {
                            return(true);
                        }
                    }
                    return(false);

                    // Return the JSON document:
                }
                return(false);
            }
            return(false);
        }
Ejemplo n.º 31
0
    public void IDictionary()
    {
        JsonValue test = new JsonValue() {
            {"one", 1},
            {"two", 2},
            {"three", 3}
        };

        Assert.That((int)test["one"], Is.EqualTo(1));
        test["one"] = 5;
        Assert.That((int)test["one"], Is.EqualTo(5));
        test["one"] = 1;

        var keys = test.Keys;
        Assert.That(keys.Count, Is.EqualTo(3));
        Assert.That(keys.Contains("one"), Is.True);
        Assert.That(keys.Contains("two"), Is.True);
        Assert.That(keys.Contains("three"), Is.True);

        var values = test.Values;
        Assert.That(values.Count, Is.EqualTo(3));
        var intvalues = values.Select(x => (int)x).ToArray();
        Array.Sort(intvalues);
        for (int i = 0; i < 3; i++) {
            Assert.That(intvalues[i], Is.EqualTo(i + 1));
        }

        test.Add("four", 4);
        Assert.That(test.Count, Is.EqualTo(4));
        Assert.That((int)test["four"], Is.EqualTo(4));

        JsonValue val;
        Assert.That(test.TryGetValue("one", out val), Is.True);
        Assert.That((int)val, Is.EqualTo(1));
        Assert.That(test.TryGetValue("seven", out val), Is.False);
        Assert.That(val, Is.Null);

        Assert.That(test.ContainsKey("four"), Is.True);
        test.Remove("four");
        Assert.That(test.Count, Is.EqualTo(3));
        Assert.That(test.ContainsKey("four"), Is.False);
    }
Ejemplo n.º 32
0
    public void DictionaryLiteral()
    {
        JsonValue test = new JsonValue() {
            {"three", 3},
            {"two", 2},
            {"one", 1},
            {"blast", "off!"}
        };
        Assert.That(test.Type, Is.EqualTo(JsonType.Object));

        Assert.That(test.ContainsKey("three"), Is.True);
        Assert.That(test.ContainsKey("two"), Is.True);
        Assert.That(test.ContainsKey("one"), Is.True);
        Assert.That(test.ContainsKey("blast"), Is.True);

        Assert.That(test["three"].Type, Is.EqualTo(JsonType.Int));
        Assert.That(test["two"].Type, Is.EqualTo(JsonType.Int));
        Assert.That(test["one"].Type, Is.EqualTo(JsonType.Int));
        Assert.That(test["blast"].Type, Is.EqualTo(JsonType.String));

        Assert.That((int)test["three"], Is.EqualTo(3));
        Assert.That((int)test["two"], Is.EqualTo(2));
        Assert.That((int)test["one"], Is.EqualTo(1));
        Assert.That((string)test["blast"], Is.EqualTo("off!"));
    }
Ejemplo n.º 33
0
 /// <summary>
 /// Get timestamp_ms field or pseudo timestamp string.
 /// </summary>
 /// <param name="graph">json object graph</param>
 /// <returns>timestamp code(millisec)</returns>
 internal static string GetTimestamp(JsonValue graph)
 {
     return graph.ContainsKey("timestamp_ms")
         ? graph["timestamp_ms"].AsString()
         : ((long)(DateTime.Now.ToUniversalTime() - StreamMessage.SerialTime)
             .TotalMilliseconds).ToString();
 }
Ejemplo n.º 34
0
 /// <summary>
 /// Check parse streamed JSON line as normal (not direct-message) status
 /// </summary>
 /// <param name="graph">JSON object graph</param>
 /// <param name="handler">stream handler</param>
 /// <returns></returns>
 internal static bool ParseStreamLineAsStatus(JsonValue graph, IStreamHandler handler)
 {
     if (!graph.ContainsKey("text")) return false;
     handler.OnStatus(new TwitterStatus(graph));
     return true;
 }
Ejemplo n.º 35
0
    public void KVPCollection()
    {
        JsonValue test = new JsonValue() {
            {"one", 1},
            {"two", 2},
            {"three", 3},
        };

        test.Remove(new KeyValuePair<string, JsonValue>("one", 1));
        Assert.That(test.Count, Is.EqualTo(2));
        Assert.Throws<KeyNotFoundException>(() => test["one"].ToString());

        KeyValuePair<string, JsonValue>[] dest = new KeyValuePair<string, JsonValue>[2];
        test.CopyTo(dest, 0);
        for (int i = 0; i < 2; ++i) {
            Assert.That(test[dest[i].Key].Equals(dest[i].Value));
        }

        Assert.That(test.Contains(new KeyValuePair<string, JsonValue>("two", 2)));

        test.Add(new KeyValuePair<string, JsonValue>("four", 4));

        Assert.That(test.ContainsKey("four"), Is.True);
        Assert.That((int)test["four"], Is.EqualTo(4));
    }
Ejemplo n.º 36
0
        internal TwitterStatus(JsonValue json)
        {
            // read numeric id and timestamp
            Id = json["id_str"].AsString().ParseLong();
            CreatedAt = json["created_at"].AsString().ParseDateTime(ParsingExtension.TwitterDateTimeFormat);

            // check extended_tweet is existed
            var exjson = json.ContainsKey("extended_tweet") ? json["extended_tweet"] : json;

            // read full_text ?? text
            var text = exjson.ContainsKey("full_text") ? exjson["full_text"] : exjson["text"];
            Text = ParsingExtension.ResolveEntity(text.AsString());

            var array = exjson["display_text_range"].AsArrayOrNull()?.AsLongArray();
            if (array != null && array.Length >= 2)
            {
                DisplayTextRange = new Tuple<int, int>((int)array[0], (int)array[1]);
            }

            if (exjson.ContainsKey("extended_entities"))
            {
                // get correctly typed entities array
                var orgEntities = TwitterEntity.ParseEntities(json["entities"]).ToArray();
                var extEntities = TwitterEntity.ParseEntities(json["extended_entities"]).ToArray();

                // merge entities
                Entities = orgEntities.Where(e => !(e is MediaEntity))
                                      .Concat(extEntities) // extended entities contains media entities only.
                                      .ToArray();
            }
            else if (exjson.ContainsKey("entities"))
            {
                Entities = TwitterEntity.ParseEntities(exjson["entities"]).ToArray();
            }
            else
            {
                Entities = new TwitterEntity[0];
            }
            if (json.ContainsKey("recipient"))
            {
                // THIS IS DIRECT MESSAGE!
                StatusType = StatusType.DirectMessage;
                User = new TwitterUser(json["sender"]);
                Recipient = new TwitterUser(json["recipient"]);
            }
            else
            {
                StatusType = StatusType.Tweet;
                User = new TwitterUser(json["user"]);
                Source = json["source"].AsString();
                InReplyToStatusId = json["in_reply_to_status_id_str"].AsString().ParseNullableId();
                InReplyToUserId = json["in_reply_to_user_id_str"].AsString().ParseNullableId();
                InReplyToScreenName = json["in_reply_to_screen_name"].AsString();

                if (json.ContainsKey("retweeted_status"))
                {
                    var retweeted = new TwitterStatus(json["retweeted_status"]);
                    RetweetedStatus = retweeted;
                    RetweetedStatusId = retweeted.Id;
                    // merge text and entities
                    Text = retweeted.Text;
                    Entities = retweeted.Entities;
                }
                if (json.ContainsKey("quoted_status"))
                {
                    var quoted = new TwitterStatus(json["quoted_status"]);
                    QuotedStatus = quoted;
                    QuotedStatusId = quoted.Id;
                }
                var coordinates = json["coordinates"].AsArrayOrNull()?.AsDoubleArray();
                if (coordinates != null)
                {
                    Longitude = coordinates[0];
                    Latitude = coordinates[1];
                }
            }
        }