private async Task OnCommand_OKAsync(object?arg)
{
var srvMessageBox = this.GetViewService <IMessageBoxService>();
var objectToExport =
from actLine in this.ExportLines
where actLine.DoExport
select actLine.ObjectToExport;
if (!objectToExport.Any())
{
await srvMessageBox.ShowAsync("Export", "Nothing to export!", MessageBoxButtons.Ok);
return;
}
// Show save file dialog
var srvSaveFile = this.GetViewService <ISaveFileViewService>();
var fileName = await srvSaveFile.ShowSaveFileDialogAsync(
new[]
{
new FileDialogFilter()
{
Name = "Data-Package (*.dataPackage)",
Extensions = { "dataPackage" }
}
}, "dataPackage");
if (string.IsNullOrEmpty(fileName))
{
return;
}
// Export the file
try
{
using (var packageFile = new DataPackageFile(fileName, FileMode.Create, FileAccess.ReadWrite))
{
packageFile.WriteSingleFile(objectToExport, _dataTypeName);
}
}
catch (Exception ex)
{
await srvMessageBox.ShowAsync(
"Export",
$"Error while exporting file:{Environment.NewLine}{ex.Message}",
MessageBoxButtons.Ok);
return;
}
// Show success message
await srvMessageBox.ShowAsync(
"Export",
$"Successfully exported {objectToExport.Count()} object(s).",
MessageBoxButtons.Ok);
this.CloseWindow(null);
}
private static void OnModuleLoad()
{
// Look for an existing DataPackages folder. If it's missing, create it.
if (!Directory.Exists(PackagesPath))
{
Directory.CreateDirectory(PackagesPath);
}
// Enumerate all packages in the directory.
// We will process these later in order by their export date.
// In other words, processing occurs from oldest to newest.
var packages = BuildPackageList();
foreach (var package in packages)
{
try
{
package.Content = File.ReadAllText(PackagesPath + package.FileName);
DataPackageFile dpf = JsonConvert.DeserializeObject <DataPackageFile>(package.Content);
package.DateExported = dpf.ExportDate;
package.PackageName = dpf.PackageName;
string processingErrors = ProcessDataPackageFile(dpf);
if (!string.IsNullOrWhiteSpace(processingErrors))
{
package.ErrorMessage = processingErrors;
}
else
{
package.ImportedSuccessfully = true;
}
}
catch (Exception ex)
{
package.ErrorMessage = ex.ToMessageAndCompleteStacktrace();
package.ImportedSuccessfully = false;
}
DataService.SubmitDataChange(package, DatabaseActionType.Insert);
if (package.ImportedSuccessfully)
{
Console.WriteLine("Processed package " + package.PackageName + " successfully.");
}
else
{
File.WriteAllText(PackagesPath + "IMPORT_FAILURE_" + package.FileName + "_" + DateTime.UtcNow.ToString("yyyy-dd-M--HH-mm-ss") + ".log", package.ErrorMessage);
Console.WriteLine("FAILURE: Package " + package.PackageName + " failed to import. Check the logs for errors.");
}
}
}
/// <inheritdoc />
public async Task <ImportResult <T>?> ImportAsync <T>(ICollection <T> importTarget, string nameProperty, string dataTypeName)
where T : class
{
var srvOpenFile = this.GetViewService <IOpenFileViewService>();
var srvMessageBox = this.GetViewService <IMessageBoxService>();
// Choose file to import
var fileToImport = await srvOpenFile.ShowOpenFileDialogAsync(
new[]
{
new FileDialogFilter()
{
Name = "Data-Package (*.dataPackage)",
Extensions = { "dataPackage" }
}
}, "dataPackage");
if (string.IsNullOrEmpty(fileToImport))
{
return(null);
}
// Import the file
List <T> importedLines;
using (var dataPackage = new DataPackageFile(fileToImport, FileMode.Open, FileAccess.Read))
{
try
{
importedLines = dataPackage.ReadSingleFile <List <T> >(dataTypeName);
}
catch (Exception ex)
{
await srvMessageBox.ShowAsync("Import", $"Error while importing: {ex.Message}", MessageBoxButtons.Ok);
return(null);
}
}
var importDlg = new ImportDialogControl();
importDlg.DataContext = new ImportDialogControlViewModel <T>(importTarget, importedLines, nameProperty);
return(await importDlg.ShowControlDialogAsync(_host, "Import")
as ImportResult <T>);
}
private static string ProcessDataPackageFile(DataPackageFile dpf)
{
string errors = string.Empty;
foreach (var obj in dpf.ApartmentBuildings)
{
errors += ValidateAndProcess(new ApartmentBuildingProcessor(), obj) + "\n";
}
foreach (var obj in dpf.BaseStructures)
{
errors += ValidateAndProcess(new BaseStructureProcessor(), obj) + "\n";
}
foreach (var obj in dpf.BuildingStyles)
{
errors += ValidateAndProcess(new BuildingStyleProcessor(), obj) + "\n";
}
foreach (var obj in dpf.CooldownCategories)
{
errors += ValidateAndProcess(new CooldownCategoryProcessor(), obj) + "\n";
}
foreach (var obj in dpf.CraftBlueprintCategories)
{
errors += ValidateAndProcess(new CraftBlueprintCategoryProcessor(), obj) + "\n";
}
foreach (var obj in dpf.CraftBlueprints)
{
errors += ValidateAndProcess(new CraftBlueprintProcessor(), obj) + "\n";
}
foreach (var obj in dpf.CraftDevices)
{
errors += ValidateAndProcess(new CraftDeviceProcessor(), obj) + "\n";
}
foreach (var obj in dpf.CustomEffects)
{
errors += ValidateAndProcess(new CustomEffectProcessor(), obj) + "\n";
}
foreach (var obj in dpf.Downloads)
{
errors += ValidateAndProcess(new DownloadProcessor(), obj) + "\n";
}
foreach (var obj in dpf.FameRegions)
{
errors += ValidateAndProcess(new FameRegionProcessor(), obj) + "\n";
}
foreach (var obj in dpf.GameTopicCategories)
{
errors += ValidateAndProcess(new GameTopicCategoryProcessor(), obj) + "\n";
}
foreach (var obj in dpf.GameTopics)
{
errors += ValidateAndProcess(new GameTopicProcessor(), obj) + "\n";
}
foreach (var obj in dpf.KeyItemCategories)
{
errors += ValidateAndProcess(new KeyItemCategoryProcessor(), obj) + "\n";
}
foreach (var obj in dpf.KeyItems)
{
errors += ValidateAndProcess(new KeyItemProcessor(), obj) + "\n";
}
//foreach (var obj in dpf.LootTableItems)
// errors += ValidateAndProcess(new LootTableItemProcessor(), obj) + "\n";
//foreach (var obj in dpf.LootTables)
// errors += ValidateAndProcess(new LootTableProcessor(), obj) + "\n";
foreach (var obj in dpf.NPCGroups)
{
errors += ValidateAndProcess(new NPCGroupProcessor(), obj) + "\n";
}
foreach (var obj in dpf.PerkCategories)
{
errors += ValidateAndProcess(new PerkCategoryProcessor(), obj) + "\n";
}
foreach (var obj in dpf.Plants)
{
errors += ValidateAndProcess(new PlantProcessor(), obj) + "\n";
}
foreach (var obj in dpf.Quests)
{
errors += ValidateAndProcess(new QuestProcessor(), obj) + "\n";
}
foreach (var obj in dpf.SkillCategories)
{
errors += ValidateAndProcess(new SkillCategoryProcessor(), obj) + "\n";
}
foreach (var obj in dpf.Skills)
{
errors += ValidateAndProcess(new SkillProcessor(), obj) + "\n";
}
foreach (var obj in dpf.Spawns)
{
errors += ValidateAndProcess(new SpawnProcessor(), obj) + "\n";
}
// Nothing in the package gets committed to the database if any error occurs.
if (string.IsNullOrWhiteSpace(errors))
{
while (_queuedDBChanges.Count > 0)
{
var change = _queuedDBChanges.Dequeue();
DataService.SubmitDataChange(change);
}
}
return(errors);
}
private DataPackageFile BuildPackage()
{
var package = new DataPackageFile(PackageName);
foreach (var group in ResourceGroups)
{
foreach (var item in group.TargetCollection)
{
switch (group.ResourceType)
{
case ResourceType.ApartmentBuildings:
var apartmentBuilding = ProcessViewModel <ApartmentBuildingViewModel, ApartmentBuilding>(item);
package.ApartmentBuildings.Add(apartmentBuilding);
break;
case ResourceType.BaseStructures:
var baseStructure = ProcessViewModel <BaseStructureViewModel, BaseStructure>(item);
package.BaseStructures.Add(baseStructure);
break;
case ResourceType.BuildingStyles:
var buildingStyle = ProcessViewModel <BuildingStyleViewModel, BuildingStyle>(item);
package.BuildingStyles.Add(buildingStyle);
break;
case ResourceType.CooldownCategories:
var cooldownCategory = ProcessViewModel <CooldownCategoryViewModel, CooldownCategory>(item);
package.CooldownCategories.Add(cooldownCategory);
break;
case ResourceType.CraftBlueprintCategories:
var craftBlueprintCategory = ProcessViewModel <CraftBlueprintCategoryViewModel, CraftBlueprintCategory>(item);
package.CraftBlueprintCategories.Add(craftBlueprintCategory);
break;
case ResourceType.CraftBlueprints:
var craftBlueprint = ProcessViewModel <CraftBlueprintViewModel, CraftBlueprint>(item);
package.CraftBlueprints.Add(craftBlueprint);
break;
case ResourceType.CraftDevices:
var craftDevice = ProcessViewModel <CraftDeviceViewModel, CraftDevice>(item);
package.CraftDevices.Add(craftDevice);
break;
case ResourceType.CustomEffects:
var customEffect = ProcessViewModel <CustomEffectViewModel, CustomEffect>(item);
package.CustomEffects.Add(customEffect);
break;
case ResourceType.Downloads:
var download = ProcessViewModel <DownloadViewModel, Download>(item);
package.Downloads.Add(download);
break;
case ResourceType.FameRegions:
var fameRegion = ProcessViewModel <FameRegionViewModel, FameRegion>(item);
package.FameRegions.Add(fameRegion);
break;
case ResourceType.GameTopicCategories:
var gameTopicCategories = ProcessViewModel <GameTopicCategoryViewModel, GameTopicCategory>(item);
package.GameTopicCategories.Add(gameTopicCategories);
break;
case ResourceType.GameTopics:
var gameTopic = ProcessViewModel <GameTopicViewModel, GameTopic>(item);
package.GameTopics.Add(gameTopic);
break;
case ResourceType.KeyItemCategories:
var keyItemCategory = ProcessViewModel <KeyItemCategoryViewModel, KeyItemCategory>(item);
package.KeyItemCategories.Add(keyItemCategory);
break;
case ResourceType.KeyItems:
var keyItem = ProcessViewModel <KeyItemViewModel, KeyItem>(item);
package.KeyItems.Add(keyItem);
break;
case ResourceType.LootTables:
JObject lootTable = ProcessViewModel <LootTableViewModel, LootTable>(item);
var vm = (LootTableViewModel)item;
foreach (var lti in vm.LootTableItems)
{
JObject ltiVM = JObject.FromObject(ProcessViewModel <LootTableItemViewModel, LootTableItem>(lti, lootTable));
package.LootTableItems.Add(ltiVM);
}
package.LootTables.Add(lootTable);
break;
case ResourceType.Mods:
var mod = ProcessViewModel <ModViewModel, Mod>(item);
package.Mods.Add(mod);
break;
case ResourceType.NPCGroups:
var npcGroup = ProcessViewModel <NPCGroupViewModel, NPCGroup>(item);
package.NPCGroups.Add(npcGroup);
break;
case ResourceType.PerkCategories:
var perkCategory = ProcessViewModel <PerkCategoryViewModel, PerkCategory>(item);
package.PerkCategories.Add(perkCategory);
break;
case ResourceType.Plants:
var plant = ProcessViewModel <PlantViewModel, Plant>(item);
package.Plants.Add(plant);
break;
case ResourceType.Quests:
var quest = ProcessViewModel <QuestViewModel, Quest>(item);
package.Quests.Add(quest);
break;
case ResourceType.SkillCategories:
var skillCategory = ProcessViewModel <SkillCategoryViewModel, SkillCategory>(item);
package.SkillCategories.Add(skillCategory);
break;
case ResourceType.Skills:
var skill = ProcessViewModel <SkillViewModel, Skill>(item);
package.Skills.Add(skill);
break;
case ResourceType.Spawns:
var spawn = ProcessViewModel <SpawnViewModel, Spawn>(item);
package.Spawns.Add(spawn);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
return(package);
}
