private void Exportdue_Click(object sender, RoutedEventArgs e)
{
if (mindate.SelectedDate != null && maxdate.SelectedDate != null)
{
var firstdate = mindate.SelectedDate.ToDateTime();
var seconddate = maxdate.SelectedDate.ToDateTime();
var min = new DateTime(firstdate.Year, firstdate.Month, firstdate.Day, minhr.Text.To <int>(), minmin.Text.To <int>(), 0);
var max = new DateTime(seconddate.Year, seconddate.Month, seconddate.Day, maxhr.Text.To <int>(), maxmin.Text.To <int>(), 0);
using (var fbd = new FolderBrowserDialog())
{
var result = fbd.ShowDialog();
if (fbd.SelectedPath.HasValue())
{
ExportHandler.Export(fbd.SelectedPath, min, max);
}
}
}
else
{
EventBus.Notify("Dates are empty", "Alert");
}
}
public static void Main()
{
Database.SetInitializer(new DropCreateDatabaseAlways <StationsContext>());
StationsContext context = new StationsContext();
QueryHelper queryHelper = new QueryHelper(context);
ImportHandler importHandler = new ImportHandler(queryHelper);
// Import JSON.
importHandler.ImportStations(File.ReadAllText("../../Datasets/stations.json"));
importHandler.ImportClasses(File.ReadAllText("../../Datasets/classes.json"));
importHandler.ImportTrains(File.ReadAllText("../../Datasets/trains.json"));
importHandler.ImportTrips(File.ReadAllText("../../Datasets/trips.json"));
// Import XML.
importHandler.ImportCards(File.ReadAllText("../../Datasets/cards.xml"));
importHandler.ImportTickets(File.ReadAllText("../../Datasets/tickets.xml"));
ExportHandler exportHandler = new ExportHandler(queryHelper);
// Export JSON.
exportHandler.ExportDelayedTrains("../../Datasets/", "01/01/2017");
exportHandler.ExportCardsTicket("../../Datasets/", "Elder");
}
/// <summary>
/// Executes the handler for an options object
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
private static ExitCode ExecuteHandler(object options)
{
ExitCode code = ExitCode.Unset;
switch (options)
{
case PrintOptions printOptions:
var printHandler = new PrintHandler(ProjectService);
code = printHandler.TryExecute(printOptions);
break;
case ExportOptions exportOptions:
var exportHandler = new ExportHandler(ProjectService);
code = exportHandler.TryExecute(exportOptions);
break;
case ExportAllOptions exportAllOptions:
var exportAllHandler = new ExportAllHandler(ProjectService);
code = exportAllHandler.TryExecute(exportAllOptions);
break;
case ImportOptions importOptions:
var importHandler = new ImportHandler(ProjectService);
code = importHandler.TryExecute(importOptions);
break;
case ImportAllOptions importAllOptions:
var importAllHandler = new ImportAllHandler(ProjectService);
code = importAllHandler.TryExecute(importAllOptions);
break;
}
return(code);
}
// Start is called before the first frame update
void Start()
{
n = Model.GetInstance().GetNumCells(0);
iterations = BacteriaFactory.GetIterations();
CellDoneHandler.Setup(n);
StartCoroutine(Load());
ExportHandler.init();
}
public IActionResult Export(string exportType, string searchString)
{
var file = new ExportHandler().Export(repo.context, typeof(Owner), searchString, exportType);
var stream = new MemoryStream(file.Data);
stream.Position = 0;
return(File(stream, file.ContentType, file.FileName));
}
/// <summary>
/// Save the SpreadsheetDocument as OpenDocument spreadsheet document
/// </summary>
/// <param name="filename">The filename. With or without full path. Without will save the file to application path!</param>
public void SaveTo(string filename)
{
this.CreateContentBody();
//Call the ExportHandler for the first matching IExporter
ExportHandler exportHandler = new ExportHandler();
IExporter iExporter = exportHandler.GetFirstExporter(
DocumentTypes.SpreadsheetDocument, filename);
iExporter.Export(this, filename);
}
private async void Exportall_Click(object sender, RoutedEventArgs e)
{
using (var fbd = new FolderBrowserDialog())
{
var result = fbd.ShowDialog();
if (fbd.SelectedPath.HasValue())
{
ExportHandler.Export(fbd.SelectedPath);
}
}
}
private void Exportthis_Click(object sender, RoutedEventArgs e)
{
using (var fbd = new FolderBrowserDialog())
{
var result = fbd.ShowDialog();
if (fbd.SelectedPath.HasValue())
{
ExportHandler.Export(fbd.SelectedPath, skip.Text.To <int>(), take.Text.To <int>());
}
}
}
public void GetExportListing()
{
// Arrange
string connectionString = @"Data Source=sqlsvr4.apexhost.net.au;Initial Catalog=construc_1;User ID=construc_usr;Password=v6x^M89;";
IDbConnection dbconnection = new System.Data.SqlClient.SqlConnection(connectionString);
var componentUnderTest = new ExportHandler(dbconnection);
// Act
var results = componentUnderTest.FetchExportListing();
// Assert
Assert.IsNotEmpty(results);
}
public void GetExportString()
{
// Arrange
string connectionString = @"Data Source=sqlsvr4.apexhost.net.au;Initial Catalog=construc_1;User ID=construc_usr;";
//string connectionString = @"Server=(LocalDB)\v11.0;Integrated Security=true;AttachDbFileName=E:\CaddyDatabase.mdf";
IDbConnection dbconnection = new System.Data.SqlClient.SqlConnection(connectionString);
var componentUnderTest = new ExportHandler(dbconnection);
// Act
var results = componentUnderTest.FetchExportStringsForID(13);
// Assert
Assert.IsNotEmpty(results);
}
public static void ExportMaterial(Scene scene, Material mat, string usdMaterialPath)
{
string shaderPath = usdMaterialPath + "/PreviewSurface";
var material = new MaterialSample();
material.surface.SetConnectedPath(shaderPath, "outputs:surface");
var origTime = scene.Time;
try
{
scene.Time = null;
scene.Write(usdMaterialPath, material);
}
finally
{
scene.Time = origTime;
}
var shader = new UnityPreviewSurfaceSample();
var texPath = /*TODO: this should be explicit*/
System.IO.Path.GetDirectoryName(scene.FilePath);
ExportHandler handler = null;
if (!ExportRegistry.TryGetValue(mat.shader.name, out handler))
{
handler = ExportRegistry[kStandardFallbackHandler];
}
if (handler == null)
{
Debug.LogException(new System.Exception("Could not find handler to export shader: " + mat.shader.name));
return;
}
try
{
scene.Time = null;
handler(scene, shaderPath, mat, shader, texPath);
scene.Write(shaderPath, shader);
}
finally
{
scene.Time = origTime;
}
}
/// <summary>
/// Gets the first importer that match the parameter criteria.
/// </summary>
/// <param name="documentType">Type of the document.</param>
/// <param name="loadPath">The save path.</param>
/// <returns></returns>
public IImporter GetFirstImporter(DocumentTypes documentType, string loadPath)
{
string targetExtension = ExportHandler.GetExtension(loadPath);
foreach (IImporter iImporter in this.LoadImporter())
{
foreach (DocumentSupportInfo documentSupportInfo in iImporter.DocumentSupportInfos)
{
if (documentSupportInfo.Extension.ToLower().Equals(targetExtension.ToLower()))
{
if (documentSupportInfo.DocumentType == documentType)
{
return(iImporter);
}
}
}
}
throw new AODLException("No importer available for type " + documentType.ToString() + " and extension " + targetExtension);
}
public override int Run(string[] remainingArguments)
{
if ((Skip.HasValue() && Take.HasValue()) || (Min.HasValue() && Max.HasValue()))
{
if (Min.HasValue() && Max.HasValue())
{
var min = DateTime.ParseExact(Min, "d", CultureInfo.InvariantCulture);
var max = DateTime.ParseExact(Max, "d", CultureInfo.InvariantCulture);
ExportHandler.Export(FileLocation, min, max);
}
if (Skip.HasValue() && Take.HasValue())
{
ExportHandler.Export(FileLocation, Skip.To <int>(), Take.To <int>());
}
}
else
{
ExportHandler.Export(FileLocation);
}
return(1);
}
/// <summary>
/// Save the TextDocument as OpenDocument textdocument.
/// </summary>
/// <param name="filename">The filename. With or without full path. Without will save the file to application path!</param>
public void SaveTo(string filename)
{
try
{
//Build document first
foreach (string font in this.FontList)
{
this.AddFont(font);
}
this.CreateContentBody();
//Call the ExportHandler for the first matching IExporter
ExportHandler exportHandler = new ExportHandler();
IExporter iExporter = exportHandler.GetFirstExporter(
DocumentTypes.TextDocument, filename);
iExporter.Export(this, filename);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Gets the first importer that match the parameter criteria.
/// </summary>
/// <param name="documentType">Type of the document.</param>
/// <param name="loadPath">The save path.</param>
/// <returns></returns>
public IImporter GetFirstImporter(DocumentTypes documentType, string loadPath, string tmpPath)
{
string targetExtension = ExportHandler.GetExtension(loadPath);
foreach (IImporter iImporter in this.LoadImporter())
{
foreach (DocumentSupportInfo documentSupportInfo in iImporter.DocumentSupportInfos)
{
if (documentSupportInfo.Extension.ToLower().Equals(targetExtension.ToLower()))
{
if (documentSupportInfo.DocumentType == documentType)
{
return(iImporter);
}
}
}
}
AODLException exception = new AODLException("No importer available for type " + documentType.ToString() + " and extension " + targetExtension);
exception.InMethod = AODLException.GetExceptionSourceInfo(new StackFrame(1, true));
throw exception;
}
private void Form1_Load(object sender, EventArgs e)
{
txtCategoryName.GotFocus += TxtCategoryName_GotFocus;
txtFunctionValue.GotFocus += TxtFunctionValue_GotFocus;
txtAchievementID.GotFocus += TxtAchievementID_GotFocus;
txtWoWPetBattleCriteria.GotFocus += TxtWoWPetBattleCriteria_GotFocus;
txtWoWPetBattleCriteria.ResetText(); // Trigger text changes
var connStrBuilder = new SqliteConnectionStringBuilder();
connStrBuilder.DataSource = "../../../../Krowi_AchievementFilter.db";
var connection = new SqliteConnection(connStrBuilder.ConnectionString);
connection.Open();
functionDataManager = new FunctionDataManager(connection);
functionHandler = new FunctionHandler(cbxFunctions, functionDataManager);
achievementCategoryDataManager = new AchievementCategoryDataManager(connection, functionDataManager);
achievementCategoryHandler = new AchievementCategoryHandler(tvwAchievementCategories, achievementCategoryDataManager, functionHandler);
achievementDataManager = new AchievementDataManager(connection);
achievementHandler = new AchievementHandler(lsbAchievements, btnUpdateAchievement_AGT, pgbUpdateAchievement_AGT, achievementDataManager, achievementCategoryHandler);
xuFuEncounterDataManager = new XuFuEncounterDataManager(connection);
xuFuEncounterHandler = new XuFuEncounterHandler(btnUpdateXuFuEncounter, pgbUpdateXuFuEncounter, xuFuEncounterDataManager);
petBattleLinksDataManager = new PetBattleLinksDataManager(connection);
petBattleLinksHandler = new PetBattleLinksHandler(petBattleLinksDataManager, achievementDataManager, xuFuEncounterDataManager);
uiMapDataManager = new UIMapDataManager(connection);
uiMapHandler = new UIMapHandler(btnUpdateUIMap, pgbUpdateUIMap, uiMapDataManager);
exportHandler = new ExportHandler((AchievementDataManager)achievementHandler.DataManager, (AchievementCategoryDataManager)achievementCategoryHandler.DataManager, (FunctionDataManager)functionHandler.DataManager, (PetBattleLinksDataManager)petBattleLinksHandler.DataManager, (UIMapDataManager)uiMapHandler.DataManager);
achievementCategoryHandler.RefreshTreeView();
functionHandler.RefreshComboBox();
btnAchievementCategoryMoveLeft.Text = char.ConvertFromUtf32(0x2190);
btnAchievementCategoryMoveUp.Text = char.ConvertFromUtf32(0x2191);
btnAchievementCategoryMoveDown.Text = char.ConvertFromUtf32(0x2193);
btnAchievementCategoryMoveRight.Text = char.ConvertFromUtf32(0x2192);
btnAchievementMoveUp.Text = char.ConvertFromUtf32(0x2191);
btnAchievementMoveDown.Text = char.ConvertFromUtf32(0x2193);
//// test
//WebClient client = new WebClient();
//StreamWriter writer = new StreamWriter(Path.Combine(Path.GetTempPath(), "testfile.txt"), true);
//for (int i = 2; i < 1000; i++)
//{
// var source = client.DownloadString($"https://www.wow-petguide.com/Strategy/{i}");
// var match = Regex.Match(source, "id=\"treasure_box.*?div", RegexOptions.Singleline);
// if (match.Success)
// {
// var s = Regex.Replace($"-- {i} -- {match.Value}", @"\s+", " ");
// writer.WriteLine(s);
// }
//}
//writer.Close();
}
// metohd to export to fetch and export the needed data ( used in LoadingScreen )
public void ExportData(int index, int iterations)
{
int currentCellNum = 0;
if (iterations == 0)
{
return;
}
var data_list = new List <object>();
List <Iteration> iteration_list = new List <Iteration>();
//List<DataToExport> data_list = new List<DataToExport>();
List <int> currentCellNumList = new List <int>();
if (index >= allCells.Count && allCells.Count == 0)
{
return;
}
for (int i = 0; i < allCells.Count; i++)
{
ForwardInternals cell = ((ForwardInternals)allCells[i].GetInternals());
for (int j = 0; j < iterations; j++)
{
float x = cell.GetPosition(j).GetX();
float z = cell.GetPosition(j).GetZ();
State interalState = cell.GetInternalStates()[j];
float ap = (float)interalState.ap;
float bp = (float)interalState.bp;
float yp = (float)interalState.yp;
float m = (float)interalState.m;
float l = (float)interalState.l;
float life = (float)interalState.life;
float death = (float)interalState.death;
int birth_date = cell.BirthDate;
int death_date = cell.DeathDate;
oneIteration = new Iteration(j, x, z, ap, bp, yp, m, l, life, death, birth_date, death_date);
iteration_list.Add(oneIteration);
}
List <Iteration> copy = new List <Iteration>(iteration_list);
cellData = new DataToExport()
{
id = i, Iterations = copy
};
data_list.Add(cellData);
iteration_list.Clear();
}
for (int i = 0; i < iterations; i++)
{
currentCellNum = GetNumCells(i);
currentCellNumList.Add(currentCellNum);
}
data_list.Add(currentCellNumList);
ExportHandler.exportData(data_list);
}
public static int Main(string[] args)
{
RegisterBlipTypes();
var serviceProvider = new ServiceCollection()
.AddSingleton <IStringService, StringService>()
.AddSingleton <NLPCompareHandler>()
.BuildServiceProvider();
return(CLI.HandleErrors(() =>
{
var app = CLI.Parser();
app.ExecutableName(typeof(Program).GetTypeInfo().Assembly.GetName().Name);
app.FromAssembly(typeof(Program).GetTypeInfo().Assembly);
app.HelpText("BLiP Command Line Interface");
_verbose = app.Switch("v").Alias("verbose").HelpText("Enable verbose output.");
_force = app.Switch("force").HelpText("Enable force operation.");
var pingHandler = new PingHandler();
var pingCommand = app.Command("ping");
pingHandler.Node = pingCommand.Parameter <string>("n").Alias("node").HelpText("Node to ping");
pingCommand.HelpText("Ping a specific bot (node)");
pingCommand.Handler(pingHandler.Run);
var nlpImportHandler = new NLPImportHandler();
var nlpImportCommand = app.Command("nlp-import");
nlpImportHandler.Node = nlpImportCommand.Parameter <string>("n").Alias("node").HelpText("Node to receive the data");
nlpImportHandler.Authorization = nlpImportCommand.Parameter <string>("a").Alias("authorization").HelpText("Node Authorization to receive the data");
nlpImportHandler.EntitiesFilePath = nlpImportCommand.Parameter <string>("ep").Alias("entities").HelpText("Path to entities file");
nlpImportHandler.IntentsFilePath = nlpImportCommand.Parameter <string>("ip").Alias("intents").HelpText("Path to intents file");
nlpImportCommand.HelpText("Import intents and entities to a specific bot (node)");
nlpImportCommand.Handler(nlpImportHandler.Run);
var copyHandler = new CopyHandler();
var copyCommand = app.Command("copy");
copyHandler.From = copyCommand.Parameter <string>("f").Alias("from").HelpText("Node (bot) source");
copyHandler.To = copyCommand.Parameter <string>("t").Alias("to").HelpText("Node (bot) target");
copyHandler.FromAuthorization = copyCommand.Parameter <string>("fa").Alias("fromAuthorization").HelpText("Authorization key of source bot");
copyHandler.ToAuthorization = copyCommand.Parameter <string>("ta").Alias("toAuthorization").HelpText("Authorization key of target bot");
copyHandler.Contents = copyCommand.Parameter <List <BucketNamespace> >("c").Alias("contents").HelpText("Define which contents will be copied").ParseUsing(copyHandler.CustomNamespaceParser);
copyHandler.Verbose = _verbose;
copyHandler.Force = _force;
copyCommand.HelpText("Copy data from source bot (node) to target bot (node)");
copyCommand.Handler(copyHandler.Run);
var saveNodeHandler = new SaveNodeHandler();
var saveNodeCommand = app.Command("saveNode");
saveNodeHandler.Node = saveNodeCommand.Parameter <string>("n").Alias("node").HelpText("Node (bot) to be saved");
saveNodeHandler.AccessKey = saveNodeCommand.Parameter <string>("k").Alias("accessKey").HelpText("Node accessKey");
saveNodeHandler.Authorization = saveNodeCommand.Parameter <string>("a").Alias("authorization").HelpText("Node authoriaztion header");
saveNodeCommand.HelpText("Save a node (bot) to be used next");
saveNodeCommand.Handler(saveNodeHandler.Run);
var formatKeyHandler = new FormatKeyHandler();
var formatKeyCommand = app.Command("formatKey").Alias("fk");
formatKeyHandler.Identifier = formatKeyCommand.Parameter <string>("i").Alias("identifier").HelpText("Bot identifier").Required();
formatKeyHandler.AccessKey = formatKeyCommand.Parameter <string>("k").Alias("accessKey").HelpText("Bot accessKey");
formatKeyHandler.Authorization = formatKeyCommand.Parameter <string>("a").Alias("authorization").HelpText("Bot authoriaztion header");
formatKeyCommand.HelpText("Show all valid keys for a bot");
formatKeyCommand.Handler(formatKeyHandler.Run);
var nlpAnalyseHandler = new NLPAnalyseHandler();
var nlpAnalyseCommand = app.Command("nlp-analyse").Alias("analyse");
nlpAnalyseHandler.Text = nlpAnalyseCommand.Parameter <string>("t").Alias("text").HelpText("Text to be analysed");
nlpAnalyseHandler.Node = nlpAnalyseCommand.Parameter <string>("n").Alias("node").Alias("identifier").HelpText("Bot identifier");
nlpAnalyseHandler.Node = nlpAnalyseCommand.Parameter <string>("a").Alias("accessKey").HelpText("Bot access key");
nlpAnalyseCommand.HelpText("Analyse some text using a bot IA model");
nlpAnalyseCommand.Handler(nlpAnalyseHandler.Run);
var exportHandler = new ExportHandler();
var exportCommand = app.Command("export").Alias("get");
exportHandler.Node = exportCommand.Parameter <string>("n").Alias("node").HelpText("Node (bot) source");
exportHandler.Authorization = exportCommand.Parameter <string>("a").Alias("authorization").HelpText("Authorization key of source bot");
exportHandler.OutputFilePath = exportCommand.Parameter <string>("o").Alias("output").Alias("path").HelpText("Output file path");
exportHandler.Model = exportCommand.Parameter <ExportModel>("m").Alias("model").HelpText("Model to be exported").ParseUsing(exportHandler.CustomParser);
exportCommand.HelpText("Export some BLiP model");
exportCommand.Handler(exportHandler.Run);
var compareHandler = serviceProvider.GetService <NLPCompareHandler>();
var compareCommand = app.Command("comp").Alias("compare");
compareHandler.Authorization1 = compareCommand.Parameter <string>("a1").Alias("authorization1").Alias("first").HelpText("Authorization key of first bot");
compareHandler.Bot1Path = compareCommand.Parameter <string>("p1").Alias("path1").Alias("firstpath").HelpText("Path of first bot containing exported model");
compareHandler.Authorization2 = compareCommand.Parameter <string>("a2").Alias("authorization2").Alias("second").HelpText("Authorization key of second bot");
compareHandler.Bot2Path = compareCommand.Parameter <string>("p2").Alias("path2").Alias("secondpath").HelpText("Path of second bot containing exported model");
compareHandler.OutputFilePath = compareCommand.Parameter <string>("o").Alias("output").Alias("path").HelpText("Output file path");
compareHandler.Method = compareCommand.Parameter <ComparisonMethod>("m").Alias("method").HelpText("Comparison method (exact, levenshtein)").ParseUsing(compareHandler.CustomMethodParser);
compareHandler.Verbose = _verbose;
compareCommand.HelpText("Compare two knowledgebases");
compareCommand.Handler(compareHandler.Run);
app.HelpCommand();
return app.Parse(args).Run();
}));
}
