/// <summary>
/// DeserializeFiles: DeserializeFiles json file to C# objects
/// </summary>
private void DeserializeFiles()
{
IInputDataReader jsonDataReader = new JsonDataReader();
inputData = jsonDataReader.DeserializeInputData(InputFile);
changeSetData = jsonDataReader.DeserializeChangeSet(ChangeFile);
}
public void Read_ShouldReturnSuccessfulResultWithExpectedData()
{
var path = TestUtils.BuildPathFor(@"DataReadersTestCases\JsonDataReaderTestCase1.json");
var expectedData = new[]
{
new Dictionary <string, double> {
{ "weight", 150.05 }, { "speed", 220.15 }, { "tyre-consumption", 0.9845 }
},
new Dictionary <string, double> {
{ "weight", 148.57 }, { "speed", 221.99 }, { "tyre-consumption", 0.9212 }
},
new Dictionary <string, double> {
{ "weight", 146.98 }, { "speed", 225.05 }, { "tyre-consumption", 0.8601 }
},
new Dictionary <string, double> {
{ "weight", 144.00 }, { "speed", 228.45 }, { "tyre-consumption", 0.7915 }
},
new Dictionary <string, double> {
{ "weight", 142.00 }, { "speed", 229.98 }, { "tyre-consumption", 0.7000 }
}
};
var reader = new JsonDataReader();
var result = reader.Read(path);
result.Data.ShouldBeEquivalentTo(expectedData);
}
public void existing_selection_should_be_expanded()
{
var lastPath = new[] { "", "Claimant", "MailingAddress", "Country", "Code" };
var nodes = JsonDataReader.BuildDataSourcePicker(SampleProjectFiles.BasicFile, SampleData.Standard, lastPath, null, 0, true);
Assert.That(nodes, Is.Not.Null, "Failed to extract picker data");
var n1 = nodes.N("");
Assert.That(n1?.Expanded, Is.True, "Data root should have been expanded");
var n2 = n1?.Nodes.N("Claimant");
Assert.That(n2?.Expanded, Is.True, "Claimant node should have been expanded");
var n3 = n2?.Nodes.N("MailingAddress");
Assert.That(n3?.Expanded, Is.True, "MailingAddress node should have been expanded");
var n4 = n3?.Nodes.N("Country");
Assert.That(n4?.Expanded, Is.True, "Country node should have been expanded");
var n5 = n4?.Nodes.N("Code");
Assert.That(n5?.Expanded, Is.True, "Code node should have been expanded");
Assert.That(n5?.Selected, Is.True, "Code node should have been selected");
}
public IActionResult DataPicker([FromQuery] int docId, [FromQuery] int?pageIndex,
[FromQuery] string?oldPath, [FromQuery] string target, [FromQuery] bool multiplesCanBePicked)
{
var sampleData = _fileDatabase.GetSampleData();
var project = _fileDatabase.GetDocumentById(docId);
string[]? repeat = null;
if (pageIndex is not null)
{
var page = project.Pages[pageIndex.Value];
if (page.RepeatMode.Repeats)
{
repeat = page.RepeatMode.DataPath;
}
}
var prev = Array.Empty <string>();
if (!string.IsNullOrWhiteSpace(oldPath))
{
prev = oldPath.Split('.');
}
var tree = JsonDataReader.BuildDataSourcePicker(project, sampleData, prev, repeat, pageIndex, multiplesCanBePicked);
var list = JsonDataReader.FlattenTree(tree);
var model = new DataSourceViewModel
{
Nodes = list, Target = target
};
return(PartialView("DataPathPicker", model) !);
}
public MessageDTO Get(string messageId, string language = "es")
{
JsonDataReader jsonDataReader = new JsonDataReader();
var messages = jsonDataReader.ReadDataFromJson <List <MessageDTO> >(MessagesJson, Encoding.UTF8);
var result = messages.Where(x => x.Language.Equals(language) && x.MessageId.Equals(messageId)).ToList();
return(result.FirstOrDefault());
}
private void ReadInData()
{
if (FolderName == null)
{
return;
}
Reader = new JsonDataReader(FolderName);
ProductProvider = Reader.ReadInData();
}
public void Read_ShouldReturnFailedResultWithExpectedMessageWhenValuesInWrongFormat()
{
var path = TestUtils.BuildPathFor(@"DataReadersTestCases\JsonDataReaderTestCase2.json");
var reader = new JsonDataReader();
var result = reader.Read(path);
result.Data.Should().BeEmpty();
result.ErrorMessage.Should().ContainEquivalentOf("could not convert string to double");
}
public void Read_ShouldReturnFailedResultWithExpectedMessageWhenFileNotFound()
{
var path = TestUtils.BuildPathFor(@"DataReadersTestCases\NotExistedFile.json");
var reader = new JsonDataReader();
var result = reader.Read(path);
result.Data.Should().BeEmpty();
result.ErrorMessage.Should().ContainEquivalentOf("Could not find file");
}
private void RegisterBinders()
{
// TODO: this should be constructed via IoC container
DataModelBinder binder = new DataModelBinder(new DataReaderProvider(new IDataReader[] {
new JsonDataReader(JsonDataReader.CreateSettings(this.Context.IsDebuggingEnabled)),
new XmlDataReader(XmlDataReader.CreateSettings(), new XmlSerializerNamespaces())
}));
binder.DefaultBinder = ModelBinders.Binders.DefaultBinder;
// set as the new default
ModelBinders.Binders.DefaultBinder = binder;
}
public void JsonDataReader_Demandbase_IP_Localhost_Test()
{
var reader = new JsonDataReader()
{
Endpoint = "http://api.demandbase.com/api/v2/ip.json"
};
reader.Parameters.Add("key", DEMANDBASE_API_KEY);
reader.Parameters.Add("query", "127.0.0.1");
var stream = reader.GetDataStream();
Assert.IsNull(stream);
}
public void when_repeater_path_is_supplied_it_should_be_added_to_tree()
{
var lastPath = new string[] {};
var repeatPath = new[] { "", "Reclaims" };
var nodes = JsonDataReader.BuildDataSourcePicker(SampleProjectFiles.BasicFile, SampleData.Standard, lastPath, repeatPath, 0, true);
Assert.That(nodes, Is.Not.Null, "Failed to extract picker data");
var pageRepeatNode = nodes.N("D");
Assert.That(pageRepeatNode, Is.Not.Null, "No repeat node in place");
Assert.That(pageRepeatNode?.Text, Is.EqualTo("Page Repeat Data"), "Bad node text");
}
public virtual void Deserialize(string key)
{
var value = UserConnection.SessionData[key] as string;
if (value == null)
{
return;
}
using (var stringReader = new StringReader(value)) {
using (var reader = new JsonDataReader(stringReader)) {
reader.Read();
ReadMetaData(reader);
}
}
}
public static T Json2Object(string json)
{
T obj = default(T);
try
{
System.IO.StringReader stringReader = new System.IO.StringReader(json);
JsonReaderSettings settings = new JsonReaderSettings();
settings.AllowNullValueTypes = true;
JsonDataReader jsonDataReader = new JsonDataReader(settings);
obj = (T)jsonDataReader.Deserialize(stringReader, typeof(T));
}
catch { }
return(obj);
}
public void repeats_with_single_items_are_still_valid()
{
var lastPath = new string[] {};
var repeatPath = new[] { "#", "HugeGroup" };
var nodes = JsonDataReader.BuildDataSourcePicker(SampleProjectFiles.BasicFile, SampleData.Standard, lastPath, repeatPath, 0, true);
Assert.That(nodes, Is.Not.Null, "Failed to extract picker data");
var node = nodes.N("D");
Assert.That(node?.Text, Is.EqualTo("Page Repeat Data"), "Bad node text");
Assert.That(node?.Nodes.Count, Is.EqualTo(6), "Wrong child-node count"); // all the reclaims should be on page 1
var subNodeData = nodes.X("D").X("[0]").N("NumberOfShares");
Assert.That(subNodeData, Is.Not.Null, "Lost path to repeater data");
}
public override void Load()
{
// serialization
this.Bind <IDataWriter>().To <JsonDataWriter>().InSingletonScope();
this.Bind <JsonWriterSettings>().ToConstant(JsonDataWriter.CreateSettings(false));
this.Bind <IDataWriter>().To <XmlDataWriter>().InSingletonScope();
this.Bind <XmlWriterSettings>().ToConstant(XmlDataWriter.CreateSettings(Encoding.UTF8, false));
this.Bind <XmlSerializerNamespaces>().ToConstant(new XmlSerializerNamespaces());
this.Bind <IDataWriterProvider>().To <DataWriterProvider>().InSingletonScope();
this.Bind <IDataReader>().To <JsonDataReader>().InSingletonScope();
this.Bind <JsonReaderSettings>().ToConstant(JsonDataReader.CreateSettings(true));
this.Bind <IDataReader>().To <XmlDataReader>().InSingletonScope();
this.Bind <XmlReaderSettings>().ToConstant(XmlDataReader.CreateSettings());
this.Bind <IDataReaderProvider>().To <DataReaderProvider>().InSingletonScope();
// MVC and IoC types
this.Bind <IActionInvoker>().To <NinjectActionInvoker>().InTransientScope();
}
public static IEnumerable <ComponentSpecification> GetComponents()
{
if (_components == null)
{
var file = new JsonDataReader().ReadSingleSpecification <ComponentSpecificationFile>(
AppEnvironment.Current.AppData + "\\Rules\\Components.json");
var localComponents = new List <ComponentSpecification>();
foreach (var code in file.Weapons)
{
localComponents.Add(new ComponentSpecification {
Code = code, ComponentType = KnownComponentTypes.Weapon
});
}
foreach (var code in file.Hulls)
{
localComponents.Add(new ComponentSpecification {
Code = code, ComponentType = KnownComponentTypes.Hull
});
}
foreach (var code in file.Specials)
{
localComponents.Add(new ComponentSpecification {
Code = code, ComponentType = KnownComponentTypes.Special
});
}
foreach (var code in file.Engines)
{
localComponents.Add(new ComponentSpecification {
Code = code, ComponentType = KnownComponentTypes.Engines
});
}
_components = localComponents;
}
return(_components);
}
public void JsonDataReader_Demandbase_IP_Test()
{
var reader = new JsonDataReader()
{
Endpoint = "http://api.demandbase.com/api/v2/ip.json"
};
reader.Parameters.Add("key", DEMANDBASE_API_KEY);
reader.Parameters.Add("query", "24.22.14.68");
var stream = reader.GetDataStream();
Assert.IsNotNull(stream);
var stream2 = new StreamReader(stream, Encoding.UTF8);
var data = stream2.ReadToEnd();
Assert.IsNotNull(data);
var obj = JsonConvert.DeserializeObject(data);
Assert.IsNotNull(obj);
}
public void array_data_should_be_selectable_when_multi_mode_is_on()
{
var lastPath = new string[] { };
var p = Strings.Separator;
var nodes = JsonDataReader.BuildDataSourcePicker(SampleProjectFiles.BasicFile, SampleData.Standard, lastPath, null, 0, true);
Assert.That(nodes, Is.Not.Null, "Failed to extract picker data");
// Check pickable paths are present
var claimantMailCode = nodes.X("").X("Claimant").X("MailingAddress").X("Country").N("Code");
Assert.That(claimantMailCode?.CanBePicked, Is.True, "pickable data is not valid");
Assert.That(claimantMailCode?.DataPath, Is.EqualTo($"{p}Claimant{p}MailingAddress{p}Country{p}Code"), "data path doesn't match node path");
Assert.That(claimantMailCode?.Depth, Is.EqualTo(4), "incorrect depth in data path");
// Check object paths are not pickable
var claimantMailCountry = nodes.X("").X("Claimant").X("MailingAddress").N("Country");
Assert.That(claimantMailCountry?.CanBePicked, Is.False, "non-pickable data is not valid");
// With multiple-mode set to true, the reclaims should be pickable
var reclaims = nodes.X("").N("Reclaims");
Assert.That(reclaims?.CanBePicked, Is.True, "multiple data was not pickable, but should have been");
// Should be able to flatten nodes
var flattened = JsonDataReader.FlattenTree(nodes).ToList();
// Nothing should be pre-selected as we gave a null path
var selected = flattened.Where(n => n.Selected).ToList();
Assert.That(selected, Is.Empty, "There were selected items with no selection path given");
// Only level-1 nodes should be expanded
var wrongExpansions = flattened.Where(n => n.Expanded != (n.Depth == 0)).ToList();
Assert.That(wrongExpansions, Is.Empty, "Some expansions were wrong");
}
private void LoadData()
{
m_DataDic.Clear();
DirectoryInfo dInfo = new DirectoryInfo(m_DataPath);
if (dInfo.Exists)
{
FileInfo[] fileInfos = dInfo.GetFiles("*.json");
if (fileInfos != null && fileInfos.Length > 0)
{
foreach (var fi in fileInfos)
{
StreamReader sr = fi.OpenText();
string content = sr.ReadToEnd();
sr.Close();
FlyerData flyerData = JsonDataReader.ReadObjectFromJson <FlyerData>(content);
m_DataDic.Add(fi.FullName, flyerData);
}
}
}
}
public void JsonDataReader_Bizo_Classify_Test()
{
var reader = new JsonDataReader()
{
Endpoint = "http://api.bizographics.com/v4/classify.json"
};
reader.UseOauth = true;
reader.OAuthApiKey = BIZO_OAUTH_API_KEY;
reader.OAuthSecret = BIZO_OAUTH_SECRET;
reader.Parameters.Add("api_key", reader.OAuthApiKey);
reader.Parameters.Add("secret", reader.OAuthSecret);
reader.Parameters.Add("ip_address", "206.108.40.109");
var stream = reader.GetDataStream();
Assert.IsNotNull(stream);
var stream2 = new StreamReader(stream, Encoding.UTF8);
var data = stream2.ReadToEnd();
Assert.IsNotNull(data);
var obj = JsonConvert.DeserializeObject(data);
Assert.IsNotNull(obj);
}
public DbConnectionTests()
{
jsonDataReader = new JsonDataReader();
dbConnectionFactory = new DbConnectionFactory();
dbConnectionBuilder = new DbConnectionBuilder();
}
public static DamageAllocationTrack GetDamageAllocationTrack(int trackNumber)
{
if (_damageAllocationChart == null)
{
var file =
new JsonDataReader().ReadSingleSpecification <DamageAllocationChartFile>(
AppEnvironment.Current.AppData + "\\Rules\\DamageAllocationChart.json");
_damageAllocationChart = new DamageAllocationChart();
foreach (var kvp in file)
{
var track = new DamageAllocationTrack();
_damageAllocationChart.Tracks.Add(kvp.Key, track);
foreach (var trackUnitCode in kvp.Value)
{
var code = trackUnitCode;
var oncePerVolley = trackUnitCode.StartsWith("_");
if (oncePerVolley)
{
code = trackUnitCode.Substring(1);
}
var isAny = trackUnitCode.StartsWith("*");
if (isAny)
{
code = trackUnitCode.Substring(1);
}
var isEndsWith = trackUnitCode.StartsWith("^");
if (isEndsWith)
{
code = trackUnitCode.Substring(1);
}
if (isAny)
{
foreach (var cmp in _components)
{
if (cmp.ComponentType == code)
{
var unit = new DamageAllocationTrackUnit
{
Id = $"{kvp.Key}-{code}",
Code = code,
OncePerVolley = oncePerVolley,
};
track.Units.Add(unit);
}
}
continue;
}
if (isEndsWith)
{
foreach (var cmp in _components)
{
if (cmp.Code.EndsWith(code))
{
var unit = new DamageAllocationTrackUnit
{
Id = $"{kvp.Key}-{code}",
Code = code,
OncePerVolley = oncePerVolley,
};
track.Units.Add(unit);
}
}
continue;
}
var unit2 = new DamageAllocationTrackUnit
{
Id = $"{kvp.Key}-{code}",
Code = code,
OncePerVolley = oncePerVolley,
};
track.Units.Add(unit2);
}
}
}
return(_damageAllocationChart.Tracks[trackNumber]);
}
public ActionResult LoadData([Bind(Include = "LayerId,DataFile")] LoadDataViewModel model)
{
try
{
logger.InfoFormat("UserId={0}", User.Identity.GetUser().Id);
if (ModelState.IsValid)
{
using (var access = new DataAccess())
{
var layer = access.Layers.Get(l => l.Id == model.LayerId, includeProperties: "Map,Columns").SingleOrDefault();
if (layer == null)
{
logger.ErrorFormat("NOT_FOUND -- Layer with id={0} not found.", model.LayerId);
ModelState.AddModelError("", Error.NOT_FOUND);
}
else if (layer.Map.User.Id != User.Identity.GetUser().Id)
{
logger.ErrorFormat("FORBIDDEN -- User with id={0} cannot access layer with id={1}.",
User.Identity.GetUser().Id, model.LayerId);
ModelState.AddModelError("", Error.FORBIDDEN);
}
else if (layer.HasData)
{
logger.ErrorFormat("UserId={0} -- Layer with id={1} already has data",
User.Identity.GetUser().Id, model.LayerId);
ModelState.AddModelError("", string.Format("Layer with id={0} already has data", model.LayerId));
}
else
{
var extension = Path.GetExtension(model.DataFile.FileName);
if (extension == ".json")
{
IList <string> messages = new List <string>();
JsonDataReader reader = new JsonDataReader();
if (!reader.LoadFile(model.DataFile.InputStream, layer, ref messages))
{
foreach (var message in messages)
{
logger.ErrorFormat("USerId={0} -- Error message={1}", User.Identity.GetUser().Id, message);
ModelState.AddModelError("", message);
}
}
else
{
layer.HasData = true;
layer.Center["lng"] = 0;
layer.Center["lat"] = 0;
layer.Center["radius"] = 0;
access.Layers.Update(layer);
access.Save();
logger.InfoFormat("UserId={0} -- successful data load.", User.Identity.GetUser().Id);
ModelState.AddModelError("", "Successful data load!");
return(RedirectToAction("Filter", new { id = model.LayerId }));
}
}
else
{
logger.ErrorFormat("UserId={0} -- Extension {1} is not supported", User.Identity.GetUser().Id, extension);
ModelState.AddModelError("", string.Format("Extension '{0}' is not supported", extension));
}
}
}
}
else
{
logger.ErrorFormat("UserId={0} -- Model state is invalid", User.Identity.GetUser().Id);
}
}
catch (Exception ex)
{
logger.Fatal("", ex);
ModelState.AddModelError("", Error.ERROR);
}
return(PartialView(model));
}
public JsonDataHandler() : base()
{
m_DataWriter = new JsonDataWriter <T>();
m_DataReader = new JsonDataReader <T>();
}
/// <summary>
/// Render a PDF into a writable stream
/// </summary>
/// <param name="fileSource">File provider, for loading backing PDFs, images, etc that may be referenced by the project file</param>
/// <param name="data">The data to be rendered into the PDF</param>
/// <param name="document">The document template project</param>
/// <param name="target">Target stream to write a PDF into</param>
/// <returns>Result information, with any error messages and timings</returns>
public static RenderResultInfo ToStream(IFileSource fileSource, object data, TemplateProject document, Stream target)
{
var standardisedData = JsonDataReader.Standardise(data);
return(new RenderProject(fileSource).ToStream(target, standardisedData, document));
}
public ActionResult Annotation()
{
ViewBag.BasicData = BasicSale.GetBasicSales();
ViewBag.FbData = JsonDataReader.GetFromAssembly <FinanceData>("fb.json");
return(View());
}
