static void Main(string[] args)
{
// Exports saved in PlanetHunters.Export/Export
JsonExport.ExportPlanets();
JsonExport.ExportAstronomers();
XmlExport.ExportStars();
}
private static void RunPardiso(MatrixFileCollection collection)
{
var benchmark = new BenchmarkPardiso(collection);
var export = new JsonExport("PARDISO", DateTime.UtcNow.ToString("s"));
benchmark.Run(export);
export.Save("benchmark-pardiso.json");
}
private static void RunSuperLU(MatrixFileCollection collection)
{
var benchmark = new BenchmarkSuperLU(collection);
var export = new JsonExport("SuperLU", DateTime.UtcNow.ToString("s"));
benchmark.Run(export);
export.Save("benchmark-superlu.json");
}
private static void RunCholmod(MatrixFileCollection collection)
{
var benchmark = new BenchmarkCholmod(collection);
var export = new JsonExport("CHOLMOD", DateTime.UtcNow.ToString("s"));
benchmark.Run(export);
export.Save("benchmark-cholmod.json");
}
private static void RunUmfpack(MatrixFileCollection collection)
{
var benchmark = new BenchmarkUmfpack(collection);
var export = new JsonExport("UMFPACK", DateTime.UtcNow.ToString("s"));
benchmark.Run(export);
export.Save("benchmark-umfpack.json");
}
static void Main(string[] args)
{
/* NB! Copy EntityFrameworkSQLServer.dll
* from Data/bin/Debug to Export/bin/Debug
*/
JsonExport.ExportPlanetsNotOriginatingAnomalies();
JsonExport.ExportPeopleNotVictimsOfAnomalies();
JsonExport.ExportAnomaliesWithMaxVictims();
XmlExport.ExportAnomaliesAndVictims();
}
public static void Main()
{
DemolitionFalconsDbContext context = new DemolitionFalconsDbContext();
SetUpDatabase.CreateDataBase(context);
Engine engine = new Engine(context);
JsonExport jsonExporter = new JsonExport();
jsonExporter.Export(context);
engine.Run();
}
public async Task <JsonExport> Get(string modelstring)
{
int arcId;
int fileId;
string[] parts = modelstring.Split(".");
fileId = int.Parse(parts[0]);
arcId = int.Parse(parts[1]);
JsonExport stuff = new JsonExport();
stuff.NoteFile = _db.NoteFile.Single(p => p.Id == fileId);
stuff.NoteHeaders = await _db.NoteHeader
.Where(p => p.NoteFileId == fileId && p.ArchiveId == arcId)
.OrderBy(p => p.NoteOrdinal)
.ThenBy(p => p.ResponseOrdinal)
.ToListAsync();
List <long> Ids = new List <long>();
foreach (NoteHeader item in stuff.NoteHeaders)
{
Ids.Add(item.Id);
}
stuff.NoteContents = await _db.NoteContent
.Where(p => Ids.Contains(p.NoteHeaderId))
.ToListAsync();
foreach (NoteContent item in stuff.NoteContents)
{
item.NoteHeader = null;
}
stuff.Tags = await _db.Tags
.Where(p => Ids.Contains(p.NoteHeaderId))
.ToListAsync();
return(stuff);
}
public ActionResult <JsonExport> GetJSON(string name, DateTime?date)
{
if (!date.HasValue)
{
date = DateTime.Today;
}
var response = new JsonExport {
Name = name
};
string docPath = pathServices.GetNamePath(name);
if (Directory.Exists(docPath))
{
response.Info = FileHelper.GetJson <GetInfoJson>(Path.Combine(docPath, "info.json"));
response.Json_data = GetTable(docPath, response.Info, date.Value);
}
return(response);
}
/// <inheritdoc />
protected override Task BeginProcessingAsync()
{
if (Path != null && !Force.IsPresent && File.Exists(Path))
{
throw new PSArgumentException("File already exists. Use -Force to use existing file.", nameof(Path));
}
string dir = System.IO.Path.GetDirectoryName(Path);
if (Path != null && !string.IsNullOrWhiteSpace(dir) && !Directory.Exists(dir))
{
throw new PSArgumentException("Path directory does not exist.", nameof(Path));
}
export = new JsonExport(Session, ExcludeDetailsByType, ExcludeDetailsByName, ExcludeByType, ExcludeByName)
{
CancellationToken = CancelProcessToken
};
return(base.BeginProcessingAsync());
}
static void Main(string[] args)
{
JsonExport.ExportPlanets();
}
public static void Main(string[] args)
{
JsonExport.ExportPlanets("TRAPPIST");
JsonExport.ExportAstronomers("Alpha Centauri");
XmlExport.ExportStars();
}
static async Task <int> MainAsync(string[] args)
{
var x = InfluxHost;
_client = new InfluxClient(new Uri(InfluxHost));
await _client.CreateDatabaseAsync(InfluxDatabaseName); // Creates Influx database if not exist
try
{
#region Test
var isDebug = true;
if (isDebug)
{
// WARNING: Remove or comment out this part for production.
var testArgs = ExecutionParamsStringExample.Split(' ');
args = testArgs;
}
#endregion Test
_parsedInputParams = ParseInputParams(args);
}
catch (Exception ex)
{
var errorMessage = "ERROR: execution params parsing failed.\r\n" + ex.Message;
Console.WriteLine(errorMessage);
return(1);
}
foreach (var testSensorsInfo in _parsedInputParams.TestSensorsInfo)
{
var query = QueryMaker.GetSensorOutputsForTest(
testSensorsInfo.TestId,
_parsedInputParams.LeftTimeBorder,
_parsedInputParams.RightTimeBorder,
testSensorsInfo.Sensors);
var resultSet = await _client.ReadAsync <SensorOutput>(InfluxDatabaseName, query);
var results = resultSet.Results[0];
var series = results.Series;
if (series.Count < 1)
{
Console.WriteLine(
$"WARNING: There were no outputs found for the specified parameters: \r\n" +
GetSearchConditionsString(_parsedInputParams.LeftTimeBorder, _parsedInputParams.RightTimeBorder,
testSensorsInfo));
continue;
}
var retrievedOutputs = series[0].Rows;
try
{
await ParseSensorsDatatypeAsync(testSensorsInfo.Sensors);
}
catch (Npgsql.PostgresException postgresException)
{
Console.WriteLine("ERROR:" + postgresException.Message);
return(1);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
var outputsForExport = ParseRetrievedData(retrievedOutputs);
var jsonExport = new JsonExport(
testSensorsInfo.TestId,
_parsedInputParams.LeftTimeBorder,
_parsedInputParams.RightTimeBorder,
outputsForExport);
var exportedFile = jsonExport.GetSensorOutputsFile();
// var directoryPath = DefaultDirectoryPath;
var directoryPath = _parsedInputParams.DirectoryPath;
try
{
FileWriter.WriteFileToDirectory(directoryPath, exportedFile.FileContents, exportedFile.FileName);
WriteSuccessMessage(
_parsedInputParams.LeftTimeBorder,
_parsedInputParams.RightTimeBorder,
testSensorsInfo,
exportedFile.FileName
);
}
catch (Exception e)
{
Console.Write("ERROR: Writing to file failed with the following message: ");
Console.WriteLine(e);
}
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
return(0);
}
// TODO sprawdzanie bledow, dokonczenie implementacji
public async System.Threading.Tasks.Task SerializeAsync()
{
Logger.Info("Serialize in Cabinet");
var serialize = new JsonExport(_config);
await serialize.ExportAsync(_mapper.Map <CabinetModelDTO>(this));
}
