Example #1
0
        /// <summary>
        /// Sends a message to the websocket API with the specified request type and optional parameters
        /// </summary>
        /// <param name="requestType">obs-websocket request type, must be one specified in the protocol specification</param>
        /// <param name="additionalFields">additional JSON fields if required by the request type</param>
        /// <returns>The server's JSON response as a JObject</returns>
        public JObject SendRequest(string requestType, JObject additionalFields = null)
        {
            string messageID;

            // Generate a random message id and make sure it is unique within the handlers dictionary
            do
            {
                messageID = NewMessageID();
            }while (_responseHandlers.ContainsKey(messageID));

            // Build the bare-minimum body for a request
            var body = new JObject();

            body.Add("request-type", requestType);
            body.Add("message-id", messageID);

            // Add optional fields if provided
            if (additionalFields != null)
            {
                var mergeSettings = new JsonMergeSettings
                {
                    MergeArrayHandling = MergeArrayHandling.Union
                };

                body.Merge(additionalFields);
            }

            // Prepare the asynchronous response handler
            var tcs = new TaskCompletionSource <JObject>();

            _responseHandlers.Add(messageID, tcs);

            // Send the message and wait for a response
            // (received and notified by the websocket response handler)
            _ws.Send(body.ToString());
            tcs.Task.Wait();

            // Throw an exception if the server returned an error.
            // An error occurs if authentication fails or one if the request body is invalid.
            var result = tcs.Task.Result;

            if ((string)result["status"] == "error")
            {
                throw new ErrorResponseException((string)result["error"]);
            }

            return(result);
        }
Example #2
0
        public JObject GetLocalization(string lang = "en")
        {
            var searchPattern = string.Format("{0}.*.json", lang);
            var files         = GetAllLocalizationFiles(searchPattern);

            var result = new JObject();

            foreach (var file in files)
            {
                var part = JObject.Parse(File.ReadAllText(file));
                result.Merge(part, new JsonMergeSettings {
                    MergeArrayHandling = MergeArrayHandling.Merge
                });
            }
            return(result);
        }
        private static void MergeWorkflowParameter(ProcessInstance processInstance, string name, JObject value)
        {
            var     workflowParams = GetWorkflowParameters(processInstance, null);
            JObject newParams      = value;

            if (workflowParams.ContainsKey(name))
            {
                newParams = workflowParams[name] as JObject;
                newParams.Merge(value, new JsonMergeSettings {
                    MergeArrayHandling = MergeArrayHandling.Merge
                });
            }
            var json = JsonConvert.SerializeObject(newParams);

            processInstance.SetParameter(name, json, ParameterPurpose.Persistence);
        }
Example #4
0
        protected virtual JObject ReadTranslationJson(IEnumerable <string> files)
        {
            var result = new JObject();

            foreach (var file in files)
            {
                if (File.Exists(file))
                {
                    var part = JObject.Parse(File.ReadAllText(file));
                    result.Merge(part, new JsonMergeSettings {
                        MergeArrayHandling = MergeArrayHandling.Merge
                    });
                }
            }
            return(result);
        }
 void IInternalConfigurationRoot.AddJsonFromStream(MemoryStream memoryStream)
 {
     using (var streamReader = new StreamReader(memoryStream))
         using (var jsonReader = new JsonTextReader(streamReader))
         {
             try
             {
                 JObject jsonObject = (JObject)JToken.ReadFrom(jsonReader);
                 _jsonRoot.Merge(jsonObject, _mergeSettings);
             }
             catch (JsonReaderException jre)
             {
                 throw new FormatException("Error reading json from config.", jre);
             }
         }
 }
Example #6
0
        public static JObject NullIfInvalid(JObject o1, JObject o2)
        {
            if (IsNull.Any(o1, o2))
            {
                return(null);
            }

            JObject result = (JObject)o1.DeepClone();

            result.Merge(o2, new JsonMergeSettings
            {
                MergeArrayHandling = MergeArrayHandling.Union
            });

            return(result);
        }
        public async void SearchSpecificationsAsyncTest(SearchOptions opts)
        {
            _api.SetResult(@"{
        result: {
          hits: ['foo', 'bar', 'baz'],
          total: 42,
          scrollId: 'foobar',
          aggregations: { agg: 'agg' }
        }
      }");

            var filters = new JObject {
                { "foo", "bar" }
            };

            SearchResults result =
                await _collectionController.SearchSpecificationsAsync(filters, opts);

            var expected = new JObject {
                { "controller", "collection" },
                { "action", "searchSpecifications" },
                { "body", filters }
            };

            if (opts != null)
            {
                expected.Merge(JObject.FromObject(opts));
            }

            _api.Verify(expected);

            Assert.Equal(
                JArray.Parse("['foo', 'bar', 'baz']"),
                result.Hits,
                new JTokenEqualityComparer());

            Assert.Equal(42, result.Total);
            Assert.Equal(3, result.Fetched);
            Assert.Equal("foobar", result.ScrollId);

            Assert.Equal(
                new JObject {
                { "agg", "agg" }
            },
                result.Aggregations,
                new JTokenEqualityComparer());
        }
Example #8
0
        public async Task <IActionResult> Get(string id)
        {
            string       fileContent = string.Empty;
            string       filePath    = FilePathHelper.GetFilePathById <CodeResponse>(id, codeResponse);
            string       fileName    = Path.GetFileName(filePath);
            CodeResponse _meta       = new CodeResponse();
            JObject      jsonObj     = new JObject();

            //get file metadata
            foreach (var record in codeResponse)
            {
                if (record.Id.ToString() == id)
                {
                    fileName = record.Name;
                    _meta    = record;
                }
            }

            try
            {
                if (!string.IsNullOrEmpty(fileName))
                {
                    using (StreamReader reader = new StreamReader(filePath))
                    {
                        fileContent = await reader.ReadToEndAsync();
                    }
                }

                string  strjObj  = JsonConvert.SerializeObject(_meta);
                JObject jObjCode = JObject.Parse(strjObj);

                //JObject jsonObj = JObject.Parse();
                jsonObj.Add("code", fileContent);

                jObjCode.Merge(jsonObj, new JsonMergeSettings
                {
                    // union array values together to avoid duplicates
                    MergeArrayHandling = MergeArrayHandling.Union
                });

                return(Json(jObjCode));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public Task <JObject> Request(JObject parameters)
        {
            var tcs   = new TaskCompletionSource <JObject>();
            int msgid = NextMessageId();

            var body = new JObject();

            body.Add("jsonrpc", "2.0");
            body.Add("id", msgid);
            body.Merge(parameters);

            string rq = body.ToString().Replace("\n", "");

            _responseHandlers.Add(msgid, tcs);
            WSConnection.SendAsync(rq, delegate(bool completed) { });
            return(tcs.Task);
        }
Example #10
0
        public void MergeObjectSelf()
        {
            var a = new JObject
            {
                ["1"] = 1,
                ["2"] = 2
            };

            a.Merge(a, new JsonMergeSettings {
                MergeArrayHandling = MergeArrayHandling.Replace
            });
            Assert.AreEqual(new JObject
            {
                ["1"] = 1,
                ["2"] = 2
            }, a);
        }
Example #11
0
        public static JObject Marge(params JObject[] objs)
        {
            if (!objs.Any())
            {
                throw new ArgumentOutOfRangeException(nameof(objs));
            }
            JObject one = objs[0];

            for (int i = 1; i < objs.Length; i++)
            {
                one.Merge(JObject.FromObject(objs[i]), new JsonMergeSettings
                {
                    MergeArrayHandling = MergeArrayHandling.Union
                });
            }
            return(one);
        }
        private void UpdateCache(JToken desiredValue)
        {
            JToken cachedToken = _desiredCache.SelectToken(PropertySectionName);

            if (cachedToken != null)
            {
                if (cachedToken is JObject)
                {
                    JObject cachedObject = (JObject)cachedToken;
                    cachedObject.Merge(desiredValue);
                }
            }
            else
            {
                _desiredCache[PropertySectionName] = desiredValue;
            }
        }
Example #13
0
        /// <summary>
        /// Get gateway.
        /// </summary>
        /// <param name="data">Additional configuration data</param>
        /// <returns>PlacetoPayRedirection instance</returns>
        public Gateway GetGateway(JObject data)
        {
            Env.Load();

            JObject config = new JObject {
                { "login", Env.GetString("P2P_LOGIN") },
                { "tranKey", Env.GetString("P2P_TRANKEY") },
                { "url", Env.GetString("P2P_URL") },
            };

            config.Merge(data, new JsonMergeSettings
            {
                MergeArrayHandling = MergeArrayHandling.Union
            });

            return(new PlacetoPayRedirection(config));
        }
Example #14
0
        internal static void MergeJsonFile(string tokenPath, string destFile, IEnumerable <string> sourceFiles)
        {
            JObject dest = new JObject();

            foreach (var file in sourceFiles)
            {
                var sourceJson = ReadFromFile(file);
                var token      = sourceJson.SelectToken(tokenPath);
                dest.Merge(token);
            }
            using (var writer = new StreamWriter(destFile, false, Encoding.UTF8))
                using (var jsonWriter = new JsonTextWriter(writer))
                {
                    var serializer = new JsonSerializer();
                    serializer.Serialize(jsonWriter, dest);
                }
        }
Example #15
0
        private static JArray ToJson(this IEnumerable <ApiValidationResult> apiValidationResults)
        {
            var apisJsonArray = new JArray();

            if (apiValidationResults != null)
            {
                foreach (var api in apiValidationResults)
                {
                    dynamic apiJson = new JObject();
                    apiJson.Name    = api.Name;
                    apiJson.Path    = api.Path;
                    apiJson.Version = api.Version;
                    if (api.ApiVersionSetId.HasValue)
                    {
                        apiJson.ApiVersionSetId = api.ApiVersionSetId.Value;
                    }

                    apiJson.Merge(api.ToJson());

                    if (api.Revisions != null && api.Revisions.Any())
                    {
                        var revisionsJsonArray = new JArray();
                        foreach (var revision in api.Revisions)
                        {
                            revisionsJsonArray.Add(revision.ToJson());
                        }

                        apiJson.Revisions = revisionsJsonArray;
                    }

                    if (api.Policies != null)
                    {
                        var apiPoliciesJson = api.Policies.ToJson();

                        if (apiPoliciesJson.HasValues)
                        {
                            apiJson.Policies = apiPoliciesJson;
                        }
                    }

                    apisJsonArray.Add(apiJson);
                }
            }

            return(apisJsonArray);
        }
Example #16
0
 public string Compare(string lang1, string lang2)
 {
     try {
         string  json1 = System.IO.File.ReadAllText(@"D:\multiLang\src\app\lang\" + lang1 + ".json");
         string  json2 = System.IO.File.ReadAllText(@"D:\multiLang\src\app\lang\" + lang2 + ".json");
         JObject o1    = JsonConvert.DeserializeObject <JObject>(json1);
         JObject o2    = JsonConvert.DeserializeObject <JObject>(json2);
         o1.Merge(o2, new JsonMergeSettings {
             // union array values together to avoid duplicates
             MergeArrayHandling = MergeArrayHandling.Union
         });
         Sort(o1);
         return(o1.ToString());
     } catch (Exception ex) {
         return(ex.ToString());
     }
 }
Example #17
0
        private JObject CreateJsonObject(IEnumerable <string> swaggerSpecs)
        {
            var jObject = new JObject();

            foreach (var spec in swaggerSpecs)
            {
                var specObject = JObject.Parse(spec);

                jObject.Merge(
                    specObject,
                    new JsonMergeSettings {
                    MergeArrayHandling = MergeArrayHandling.Union
                });
            }

            return(jObject);
        }
Example #18
0
        //Unions a list of deserialized json class data.
        public static JObject MergeJSON <T>(List <T> json)
        {
            JObject jO = new JObject();

            foreach (T o in json)
            {
                JObject jO1 = JObject.Parse(Convert.ToString(o));

                jO.Merge(jO1, new JsonMergeSettings
                {
                    // union array values together to avoid duplicates
                    MergeArrayHandling = MergeArrayHandling.Union
                });
            }

            return(jO);
        }
Example #19
0
        private string MergeJson()
        {
            JObject o1 = JObject.Parse(@"{
  'FirstName': 'John',
  'LastName': {
    'FamilyName': 'abc',
    'Surname': 'def',
    'a': {
        'b': {
            'c': {
                    'd': {
                        'e': 10
                    },
                    'f': 11
                }
            }
        }
    },
  'Enabled': false,
  'Roles': [ 'User']
}");
            JObject o2 = JObject.Parse(@"{
  'FirstName': 'Apple',
'Roles': [ 'DDD', 'Datra'],
  'LastName': {
    'FamilyName': 'abc',
    'Surname': 'def',
    'a': {
        'b': {
            'e': 10
        }
    }
   },
  'Enabled': true  
}");

            o1.Merge(o2, new JsonMergeSettings
            {
                // union array values together to avoid duplicates
                MergeArrayHandling = MergeArrayHandling.Union
            });

            string json = o1.ToString();

            return(json);
        }
Example #20
0
        public async Task <IActionResult> Swagger()
        {
            JObject json = new JObject();
            var     directoryContents = _fileProvider.GetDirectoryContents("swagger/v1");

            foreach (IFileInfo fi in directoryContents)
            {
                await using var stream = fi.CreateReadStream();
                using var reader       = new StreamReader(fi.CreateReadStream());
                json.Merge(JObject.Parse(await reader.ReadToEndAsync()));
            }
            var servers = new JArray();

            servers.Add(new JObject(new JProperty("url", HttpContext.Request.GetAbsoluteRoot())));
            json["servers"] = servers;
            return(Json(json));
        }
        private static void PatchOfficialSpec(JObject original, string jsonFile)
        {
            var directory = Path.GetDirectoryName(jsonFile);
            var patchFile = Path.Combine(directory, Path.GetFileNameWithoutExtension(jsonFile)) + ".patch.json";

            if (!File.Exists(patchFile))
            {
                return;
            }

            var patchedJson = JObject.Parse(File.ReadAllText(patchFile));

            original.Merge(patchedJson, new JsonMergeSettings
            {
                MergeArrayHandling = MergeArrayHandling.Union
            });
        }
Example #22
0
        public void JoinTest()
        {
            FileLog _logger = new FileLog("JsonValueExtensionsTests", new FileLogSettings()
            {
                DateFolderMask = "yyyy-MM-dd"
            });
            JObject v = new JObject
            {
                ["test1"] = 10,
                ["test2"] = "test string",
                ["text3"] = DateTime.Now
            };

            v.Merge(_v);
            _logger.Debug(v.ToString(Newtonsoft.Json.Formatting.Indented));
            _logger.Flush();
        }
        private static JObject InnerReadLocalization(IContentBlobProvider themeBlobProvider, string themePath, Language language)
        {
            JObject retVal           = null;
            var     localeFolderPath = Path.Combine(themePath, "locales");

            if (themeBlobProvider.PathExists(localeFolderPath))
            {
                JObject localeJson  = null;
                JObject defaultJson = null;

                foreach (var languageName in new[] { language.CultureName, language.TwoLetterLanguageName })
                {
                    var currentLocalePath = Path.Combine(localeFolderPath, string.Concat(languageName, ".json"));

                    if (themeBlobProvider.PathExists(currentLocalePath))
                    {
                        using (var stream = themeBlobProvider.OpenRead(currentLocalePath))
                        {
                            localeJson = JsonConvert.DeserializeObject <dynamic>(stream.ReadToString());
                        }
                        break;
                    }
                }

                var localeDefaultPath = themeBlobProvider.Search(localeFolderPath, "*.default.json", false).FirstOrDefault();

                if (localeDefaultPath != null && themeBlobProvider.PathExists(localeDefaultPath))
                {
                    using (var stream = themeBlobProvider.OpenRead(localeDefaultPath))
                    {
                        defaultJson = JsonConvert.DeserializeObject <dynamic>(stream.ReadToString());
                    }
                }

                //Need merge default and requested localization json to resulting object
                retVal = defaultJson ?? localeJson;

                if (defaultJson != null && localeJson != null)
                {
                    retVal.Merge(localeJson, new JsonMergeSettings {
                        MergeArrayHandling = MergeArrayHandling.Merge
                    });
                }
            }
            return(retVal);
        }
        public PersonEntity Merge(PersonEntity source)
        {
            JObject jsonSource = JObject.Parse(JsonConvert.SerializeObject(source));

            JObject jsonDestination = JObject.Parse(JsonConvert.SerializeObject(this,
                                                                                new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore
            }));

            jsonSource.Merge(jsonDestination, new JsonMergeSettings
            {
                MergeArrayHandling = MergeArrayHandling.Union
            });

            return(JsonConvert.DeserializeObject <PersonEntity>(jsonSource.ToString()));
        }
        /// <summary>
        /// Set settings of the specified BrowserSource
        /// </summary>
        /// <param name="sourceName">Source name</param>
        /// <param name="props">BrowserSource properties</param>
        /// <param name="sceneName">Optional name of a scene where the specified source can be found</param>
        public void SetBrowserSourceProperties(string sourceName, BrowserSourceProperties props, string sceneName = null)
        {
            var request = new JObject();

            request.Add("source", sourceName);
            if (sceneName != null)
            {
                request.Add("scene-name", sourceName);
            }

            request.Merge(props.ToJSON(), new JsonMergeSettings()
            {
                MergeArrayHandling = MergeArrayHandling.Union
            });

            SendRequest("SetBrowserSourceProperties", request);
        }
Example #26
0
        public HttpResponseMessage Post([FromBody] Command command)
        {
            JObject commandOject    = JObject.Parse(JsonConvert.SerializeObject(command));
            JObject newCommandOject = JObject.Parse(command.Change.CommandJSON);

            commandOject.Merge(newCommandOject, new JsonMergeSettings
            {
                MergeArrayHandling = MergeArrayHandling.Union
            });

            var commandType = Type.GetType(command.Change.CommandName);
            var commandObj  = commandOject.ToObject(commandType);

            var response = mediator.Send((IRequest <HttpStatusCode>)commandObj).Result;

            return(new HttpResponseMessage(response));
        }
Example #27
0
        /// <summary>
        /// Get carrier instance.
        /// </summary>
        /// <returns>Carrier instance.</returns>
        private Carrier Carrier()
        {
            if (carrier is Carrier)
            {
                return(carrier);
            }

            JObject        config      = this.config;
            Authentication auth        = new Authentication(config);
            string         requestType = this.requestType;

            JObject typeConfig = config.ContainsKey(requestType)
                ? config.GetValue(requestType).ToObject <JObject>()
                : new JObject();

            if (requestType == TP_SOAP)
            {
                var carrierConfig = new JObject
                {
                    { "location", $"{config[URL]}soap/redirect" },
                };

                carrierConfig.Merge(typeConfig, new JsonMergeSettings
                {
                    MergeArrayHandling = MergeArrayHandling.Union
                });

                carrier = new SoapCarrier(auth, carrierConfig);
            }
            else
            {
                var carrierConfig = new JObject
                {
                    { URL, config.GetValue(URL).ToString() },
                };

                carrierConfig.Merge(typeConfig, new JsonMergeSettings
                {
                    MergeArrayHandling = MergeArrayHandling.Union
                });

                carrier = new RestCarrier(auth, carrierConfig);
            }

            return(carrier);
        }
        private void IterateJsonProperties(ref JObject rootOrigin, JToken environmentSpecific)
        {
            if (environmentSpecific == null || rootOrigin == null)
            {
                return;
            }

            bool skipChildren = false;

            if (environmentSpecific is JValue)
            {
                skipChildren = true;
            }

            if (environmentSpecific is JObject)
            {
                var typeChild = environmentSpecific["$type"];
                if (typeChild != null && !typeChild.ToString().Equals("System.Collections.Generic.List`1[[Sitecore.Commerce.Core.Policy, Sitecore.Commerce.Core]], mscorlib"))
                {
                    JToken  matchingOriginElement = FindMatchingElement(rootOrigin, typeChild);
                    JObject originObject          = matchingOriginElement.Parent.Parent as JObject;
                    originObject.Merge(environmentSpecific, new JsonMergeSettings()
                    {
                        MergeArrayHandling = MergeArrayHandling.Merge
                    });
                    skipChildren = true;
                }
            }

            if (!skipChildren)
            {
                JToken specificChild = environmentSpecific.Children().Any() ? environmentSpecific.First() : null;
                if (specificChild != null)
                {
                    IterateJsonProperties(ref rootOrigin, specificChild);
                }
            }

            JToken specificNext = environmentSpecific.Next;

            if (specificNext != null)
            {
                IterateJsonProperties(ref rootOrigin, specificNext);
            }
        }
Example #29
0
        static JObject GetSettings(
            IEnumerable <string> configurationSections,
            string json,
            JObject defaultSettings)
        {
            JObject settings = ReadJson(json);

            var sectionsList = configurationSections
                               .Select(section => section + ".")
                               .ToList();

            bool hasSettings = false;

            foreach (JProperty prop in settings.Properties().ToList())
            {
                if (IncludedInSection(prop.Name, sectionsList))
                {
                    hasSettings = true;
                }
                else
                {
                    settings.Remove(prop.Name);
                }
            }

            if (hasSettings && defaultSettings != null)
            {
                var mergeSettings = new JsonMergeSettings {
                    MergeArrayHandling = MergeArrayHandling.Merge
                };
                defaultSettings.Merge(settings, mergeSettings);

                return(defaultSettings.GroupByParentSection(configurationSections));
            }
            else if (hasSettings)
            {
                return(settings.GroupByParentSection(configurationSections));
            }
            else if (defaultSettings != null)
            {
                return(defaultSettings.GroupByParentSection(configurationSections));
            }

            return(null);
        }
        public void HandleCommand(GenerateUserDataCommand command)
        {
            var content = Convert.ToBase64String(File.ReadAllBytes(Filename));

            var userData = new JObject
            {
                ["packages"] = new JArray
                {
                    "unzip"
                },

                ["write_files"] = new JArray
                {
                    new JObject
                    {
                        ["encoding"]   = "b64",
                        ["content"]    = content,
                        ["owner"]      = "root:root",
                        ["path"]       = "/tmp/init.zip",
                        ["permission"] = "0644"
                    }
                },

                ["runcmd"] = new JArray
                {
                    "unzip /tmp/init.zip -d /tmp/init",
                    "rm /tmp/init.zip",
                    "chmod +x /tmp/init/init.sh",
                    "/tmp/init/init.sh"
                }
            };


            _decoratedHandler.HandleCommand(command);


            if (command.UserDataJson != null)
            {
                userData.Merge(command.UserDataJson, new JsonMergeSettings {
                    MergeArrayHandling = MergeArrayHandling.Union
                });
            }

            command.UserDataJson = userData;
        }
Example #31
0
        public void MergeNull()
        {
            JConstructor c = new JConstructor();
            c.Merge(null);
            Assert.Equal(null, c.Name);
            Assert.Equal(0, c.Count);

            JObject o = new JObject();
            o.Merge(null);
            Assert.Equal(0, o.Count);

            JArray a = new JArray();
            a.Merge(null);
            Assert.Equal(0, a.Count);

            JProperty p = new JProperty("name1");
            p.Merge(null);
            Assert.Equal("name1", p.Name);
            Assert.Equal(0, p.Count);
        }