private void OpenFile()
{
var dialog = new OpenFileDialog();
dialog.DefaultExt = ".json";
dialog.Filter = "Json documents (.json)|*.json";
var res = dialog.ShowDialog();
if (res == true)
{
var fileName = dialog.FileName;
try
{
var timeLine = JsonImporter.Import(fileName);
Documents.Add(new DocumentVM(fileName, timeLine));
} catch (JsonException e)
{
MessageBox.Show($"There was errors while parse file: \n {e.Message}");
}
}
}
public void GetTheParametersOfJSONDllTestOk()
{
ReflectionLogic reflectionLogic = new ReflectionLogic();
List <Parameter> parametersOfImporterJson = reflectionLogic.GetTheParametersRequired("\\Importers\\ImporterJson.dll");
JsonImporter importerJson = new JsonImporter();
CollectionAssert.AreEqual(importerJson.GetParameter(), parametersOfImporterJson);
}
public void ReadDataTest()
{
JsonImporter <UserNames.Lib.Models.User> importer = new JsonImporter <UserNames.Lib.Models.User>();
List <UserNames.Lib.Models.User> users = importer.Read();
Assert.NotNull(users);
}
private void ResetDatabase(JsonImporter jsonImporter)
{
using (var context = new CarDealerContext())
{
context.Database.EnsureDeleted();
context.Database.Migrate();
}
jsonImporter.Import();
}
public void ImportToJsonType1()
{
ModelExportImport model =
JsonImporter.Import("json\\name1.json");
if (model != null)
{
if (model.stuffs[0].id == model.stuffs[0].result)
{
;
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Select your option");
Console.WriteLine("1: Read from XML");
Console.WriteLine("2: Read from JSON");
var key = Console.ReadKey(false);
IEnumerable <Horse> horses = new List <Horse>();
IImporter importer;
while (key.Key == ConsoleKey.D1 || key.Key == ConsoleKey.D2)
{
if (key.Key == ConsoleKey.D1)
{
importer = new XMLImporter();
horses = importer.Import();
break;
}
else
{
importer = new JsonImporter();
horses = importer.Import();
break;
}
}
//Console.WriteLine("Press any key to read from XML file and display horses");
Console.ReadKey();
Console.WriteLine("Now printing horses...");
//Ascending order of horses by price
horses = horses.OrderBy(h => h.Price);
Console.WriteLine("-----------------------------------------------");
Console.WriteLine("Ordering horses by ascending order of their prices.");
Console.WriteLine("Horse Name | Price");
foreach (var horse in horses)
{
Console.WriteLine(horse.Name + " | " + horse.Price);
}
Console.WriteLine("Press any key to end");
Console.ReadKey();
}
public virtual void InitImports()
{
_imports = new Dictionary <string, IImportable>();
IImportable import;
import = new JsonImporter();
_imports.Add(import.Type, import);
import = new BinaryImporter();
_imports.Add(import.Type, import);
import = new CsvImporter();
_imports.Add(import.Type, import);
// add new import types here
}
// TODO : �ٸ� ������Ʈ�� Ŭ���ϰ� ���ƿ����� ������ ���°� �����Ǹ� ������
private void OnEnable()
{
mapLoader = (MapLoader)target;
// ���� �����ϴ� ��� Ÿ�ϸ� ����
tileMaps = FindObjectsOfType <Tilemap>();
// ���⼭ ������ ��ü ����Ʈ ����
var itemDatabase = JsonImporter.LoadJsonFile <ItemDatabase>(itemDataPath, "ItemDatabase");
allItems = itemDatabase.AllItem;
itemNameList = new List <string>();
foreach (var item in allItems)
{
itemNameList.Add(item.itemName);
}
}
private void LoadTileMap(string name, Transform parent = null)
{
var o = Instantiate(mapLoader.transform.Find("TileMapEmpty"));
o.name = name;
o.parent = parent;
var tileMap = o.GetComponent <Tilemap>();
var data = JsonImporter.LoadJsonFile <TileMapData>(mapDataPath, name);
var tileNames = data.tileNames;
var tilePos = data.tilePos;
var length = tileNames.Count;
for (int i = 0; i < length; ++i)
{
tileMap.SetTile((Vector3Int)tilePos[i], (TileBase)Resources.Load("Tileset/" + tileNames[i]));
}
}
/// <summary>
/// Handle Import Button Click: call jsonimporter given correct prevariants
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ImportButton_Click(object sender, EventArgs e)
{
bool boxItemSelected = (selectDatasetBox.SelectedIndex != -1);
if (boxItemSelected)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "JSON (*.json)|*.json";
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
JsonImporter.ImportMongoCollection(GetSelectedBoxAsCollectionName(), openFileDialog.FileName);
}
}
else
{
MessageBox.Show("Please make a selection in the drop down menu");
}
}
private int OnExecute(IConsole console)
{
try {
var config = Importing.Configuration.ConfigurationImporter.ImportConfiguration(ConfigFile);
var jsonImporter = new JsonImporter();
var factory = new Core.CoreFactory();
var testRunGroup = factory.CreateTestRunGroup(config.TestRunGroupReport.ReportName);
var reasons = string.Join(",", config.SortedReasonConfigurations.Select(x => x.Reason).ToArray());
console.WriteLine($"Output: {config.TestRunGroupReport.FileName}");
console.WriteLine($"Name: {config.TestRunGroupReport.ReportName}");
console.WriteLine($"TestRunNameClip: {config.TestRunGroupReport.RootNameSkip}");
console.WriteLine($"Reasons: {reasons}");
if (config.TestRunGroupReport.TestRunConfigurations == null || config.TestRunGroupReport.TestRunConfigurations.Count == 0)
{
throw new Exception("No test run configurations specified.");
}
foreach (var testRunConfiguration in config.TestRunGroupReport.TestRunConfigurations)
{
var jsonReport = testRunConfiguration.JsonFilePath;
var htmlReport = testRunConfiguration.TestRunUrl;
console.WriteLine($"Json Report: {jsonReport}");
var testRunJson = System.IO.File.ReadAllText(jsonReport);
var testRun = jsonImporter.ImportJson(testRunJson);
testRun.CalculateStartAndEndTimes();
testRun.UpdateParentReasonsAndStats(config.SortedReasonConfigurations.Select(x => x.Reason).ToList());
testRun.UpdateStats();
testRun.FilePath = htmlReport;
testRunGroup.TestRuns.Add(testRun);
}
testRunGroup.CalculatProperties(config.SortedReasonConfigurations.Select(x => x.Reason).ToList());
var html = testRunGroup.WriteToHtmlSummaryReport(config.TestRunGroupReport, config.SortedReasonConfigurations);
System.IO.FileInfo file = new System.IO.FileInfo(config.TestRunGroupReport.FileName);
file.Directory.Create();
System.IO.File.WriteAllText(file.FullName, html);
return(0);
} catch (Exception ex) {
console.Error.WriteLine($"Error: {ex.Message}");
return(1);
}
}
static void Main(string[] args)
{
DataImporter <User> importer = new JsonImporter <User>();
var userList = importer.Read();
UserManager manager = new UserManager(userList);
// The users full name for id=42
var user1 = manager.GetUser(42);
if (user1 != null)
{
Console.WriteLine("{0} {1}", user1.first, user1.last);
}
Console.WriteLine(Environment.NewLine);
// All the users first names (comma separated) who are 23
var usersByAge = manager.GetUsersByAge(23);
int cnt = 0;
foreach (var user in usersByAge)
{
if (cnt++ > 0)
{
Console.Write(", ");
}
Console.Write(user.first);
}
Console.WriteLine(Environment.NewLine);
// The number of genders per Age, displayed from youngest to oldest
var gendersByAge = manager.GetGendersByAge();
foreach (var result in gendersByAge)
{
Console.WriteLine("Age : {0} Female: {1} Male:{2}", result.age, result.female, result.male);
}
Console.ReadLine();
}
private void MoveObject()
{
foreach (GameObject objFile in objFiles)
{
var jsonStr = JsonImporter.JsonToString(objFile.name);
if (jsonStr.Equals("error"))
{
return;
}
var json = JsonConvert.DeserializeObject <PointC>(jsonStr);
objFile.transform.position = new Vector3(json.PosX, json.PosY, json.PosZ); // objファイルを移動させる
objFile.transform.Rotate(new Vector3(0, json.RotY, 0)); // objファイルを回転させる
Debug.Log("PosX : " + json.PosX);
Debug.Log("PosY : " + json.PosY);
Debug.Log("PosZ : " + json.PosZ);
Debug.Log("RotY : " + json.RotY);
}
Debug.Log("MoveObject() : Done");
}
public Task Run()
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("IMPORT JSON TEXT AND APPARATUS\n");
Console.ResetColor();
Console.WriteLine(
$"Text dir: {_txtFileDir}\n" +
$"Text mask: {_txtFileMask}\n" +
$"Apparatus dir: {_appFileDir}\n" +
$"Profile file: {_profilePath}\n" +
$"Database: {_database}\n" +
$"Dry run: {_dry}\n");
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddSerilog(Log.Logger);
Log.Logger.Information("IMPORT JSON TEXT AND APPARATUS");
if (!_dry)
{
// create database if not exists
string connection = string.Format(CultureInfo.InvariantCulture,
_config.GetConnectionString("Mongo"),
_database);
IDatabaseManager manager = new MongoDatabaseManager();
string profileContent = LoadProfile(_profilePath);
IDataProfileSerializer serializer = new JsonDataProfileSerializer();
DataProfile profile = serializer.Read(profileContent);
if (!manager.DatabaseExists(connection))
{
Console.WriteLine("Creating database...");
Log.Information($"Creating database {_database}...");
manager.CreateDatabase(connection, profile);
Console.WriteLine("Database created.");
Log.Information("Database created.");
}
}
else
{
if (!File.Exists(_profilePath))
{
string error = "Profile path not found: " + _profilePath;
Console.WriteLine(error);
Log.Error(error);
return(Task.CompletedTask);
}
}
ICadmusRepository repository =
_repositoryService.CreateRepository(_database);
JsonImporter importer = new JsonImporter(repository)
{
Logger = loggerFactory.CreateLogger("json-importer"),
IsDry = _dry
};
int inputFileCount = 0;
// 1) import text
string[] files = FileEnumerator.Enumerate(
_txtFileDir, _txtFileMask, _regexMask).ToArray();
HashSet <string> fileNames = new HashSet <string>();
Console.WriteLine($"Importing text from {files.Length} file(s)...");
foreach (string txtFilePath in files)
{
fileNames.Add(
StripFileNameNr(
Path.GetFileNameWithoutExtension(txtFilePath)));
Console.WriteLine(txtFilePath);
inputFileCount++;
using (Stream stream = new FileStream(txtFilePath, FileMode.Open,
FileAccess.Read, FileShare.Read))
{
importer.ImportText(stream);
}
}
// 2) import apparatus
Console.WriteLine("Importing apparatus...");
foreach (string fileName in fileNames)
{
Console.WriteLine(fileName);
foreach (string appFilePath in Directory.EnumerateFiles(
_appFileDir, fileName + "-app_*.json"))
{
Console.WriteLine(" " + appFilePath);
using (Stream stream = new FileStream(appFilePath, FileMode.Open,
FileAccess.Read, FileShare.Read))
{
importer.ImportApparatus(stream);
}
}
}
return(Task.CompletedTask);
}
public async Task Run(string[] args)
{
var importers = LoadImporters(Configuration);
string dataDirectory;
if (args.Length != 0)
{
dataDirectory = args[0];
}
else
{
dataDirectory = Configuration["dataDirectory"];
}
foreach (var importer in importers.Where(i => i.IsActive))
{
if (importer.Type == ImporterType.TextImporter && importer.ImportModel == "TaxonomicUnit")
{
var processor = _importTransformOrchestrator.GetPlantInfoProcessor;
var transformer = new USDATransformer();
var startRow = 1;
var batchSize = 100;
await processor.InitializeOrigin(transformer.Origin);
await processor.InitializeLifeforms();
await processor.InitializeTaxons();
var dataFile = FileHelpers.GetDatafileName(importer.Filename, dataDirectory);
var textImporter = new TextImporter <Checklist>(dataFile, importer.HasHeaders);
var row = 1;
var checklists = new List <Checklist>();
await foreach (var result in textImporter.Import())
{
row++;
if (row < startRow)
{
continue;
}
else if (row % batchSize != 0)
{
checklists.Add(result);
}
else
{
if (checklists.Any())
{
await ProcessChecklists(transformer, processor, checklists);
checklists.Clear();
}
}
if (checklists.Any())
{
await ProcessChecklists(transformer, processor, checklists);
checklists.Clear();
}
}
}
else if (importer.Type == ImporterType.SqlImporter && importer.ImportModel == "TaxonomicUnit")
{
var processor = _importTransformOrchestrator.GetPlantInfoProcessor;
var sqlImporter = new SqlImporter <TaxonomicUnit>(importer.ConnectionString, importer.SqlQuery);
var transformer = new ITISPlantInfoTransformer();
var startRow = 0;
var batchSize = 100;
var row = 0;
var taxonomicUnits = new List <TaxonomicUnit>();
await processor.InitializeOrigin(transformer.Origin);
await processor.InitializeLifeforms();
await processor.InitializeTaxons();
await foreach (var result in sqlImporter.Import())
{
row++;
if (row < startRow)
{
continue;
}
else if (row % batchSize != 0)
{
taxonomicUnits.Add(result);
}
else
{
if (taxonomicUnits.Any())
{
await ProcessTaxonomicUnits(transformer, processor, taxonomicUnits);
taxonomicUnits.Clear();
}
}
}
if (taxonomicUnits.Any())
{
await ProcessTaxonomicUnits(transformer, processor, taxonomicUnits);
taxonomicUnits.Clear();
}
}
else if (importer.Type == ImporterType.SqlImporter && importer.ImportModel == "Vernacular")
{
var processor = _importTransformOrchestrator.GetSynonymProcessor;
var sqlImporter = new SqlImporter <Vernacular>(importer.ConnectionString, importer.SqlQuery);
var transformer = new ITISSynonymTransformer();
var startRow = 0;
var batchSize = 500;
var row = 0;
var vernaculars = new List <Vernacular>();
await processor.InitializeOrigin(transformer.Origin);
await processor.InitializeTaxons();
await foreach (var result in sqlImporter.Import())
{
row++;
if (row < startRow)
{
#pragma warning disable S3626 // Jump statements should not be redundant
continue;
#pragma warning restore S3626 // Jump statements should not be redundant
}
else if (row % batchSize != 0)
{
vernaculars.Add(result);
}
else
{
await ProcessSynonyms(transformer, processor, vernaculars);
vernaculars.Clear();
}
}
if (vernaculars.Any())
{
await ProcessSynonyms(transformer, processor, vernaculars);
vernaculars.Clear();
}
}
else if (importer.Type == ImporterType.EFImporter && importer.ImportModel == "PlantInfo")
{
var processor = _importTransformOrchestrator.GetElasticPlantInfoProcessor;
var finished = false;
var counter = 0;
var counterEnd = 40000;
while (!finished && counter < counterEnd)
{
//var response = await processor.Process(counter, counter + 1000);
var response = await processor.ProcessSome(counter, 1000);
Console.WriteLine($"Successes: {response.Successes} / Failures: {response.Failures}");
if (response.Failures > 0)
{
throw new Exception("Errors! Noooooo!");
}
else if (response.Successes == 0)
{
finished = true;
}
counter += 1000;
}
}
else if (importer.Type == ImporterType.EFImporter && importer.ImportModel == "Specimen")
{
var processor = _importTransformOrchestrator.GetElasticSpecimenProcessor;
var finished = false;
var counter = 0;
var counterEnd = 1000000;
while (!finished && counter < counterEnd)
{
var response = await processor.Process(counter, counter + 1000);
Console.WriteLine($"Successes: {response.Successes} / Failures: {response.Failures}");
if (response.Failures > 0)
{
throw new Exception("Errors! Noooooo!");
}
else if (response.Successes == 0)
{
finished = true;
}
counter += 1000;
}
}
else if (importer.Type == ImporterType.JsonImporter && importer.ImportModel == "PlantsFile")
{
var transformer = new NatureServeTransformer();
var dataFile = FileHelpers.GetDatafileName(importer.Filename, dataDirectory);
var textImporter = new JsonImporter <IEnumerable <Plant> >(dataFile);
var plants = textImporter.ImportObjectAsync();
var plantInfos = new List <PlantInfo>();
List <Taxon> taxons;
List <Lifeform> lifeforms;
List <Origin> origins;
foreach (var plant in plants)
{
plantInfos.Add(transformer.Transform(plant));
}
var processor = _importTransformOrchestrator.GetNatureServePlantInfoProcessor();
await processor.InitializeOrigin(transformer.Origin);
await processor.InitializeLifeforms();
await processor.InitializeTaxons();
await processor.InitializeOrigins();
taxons = processor.Taxons;
lifeforms = processor.Lifeforms;
origins = processor.Origins;
var batchSize = 500;
var finished = false;
var start = 0;
var counter = start;
var counterEnd = 40000;
plantInfos = plantInfos.OrderBy(p => p.Origin.ExternalId).ToList();
while (!finished && counter < counterEnd)
{
if (counter > start)
{
processor = _importTransformOrchestrator.GetNatureServePlantInfoProcessor(lifeforms, taxons, origins);
await processor.InitializeOrigin(transformer.Origin);
}
var batch = plantInfos.Skip(counter).Take(batchSize);
if (!batch.Any())
{
finished = true;
continue;
}
var result = await processor.Process(batch);
Console.WriteLine($"Processed: {result.Count()} plantInfos - ended on {batch.Last().ScientificName}");
counter += batchSize;
}
}
}
}
