public static void LoadConfig(string path)
{
try
{
if (!File.Exists(Path.Combine(path, "Config.xml")))
{
ConfigManager cm = new ConfigManager()
{
PDF = new List <string>()
{
"DefaultPDF.xml", "AlternatePDF.xml"
}
};
cm.Save(Path.Combine(path, "Config.xml"));
}
ConfigManager loaded = Program.Context.LoadConfig(path);
PDFExporter = PDF.Load(ImportExtensions.Fullpath(path, loaded.PDF[0]));
Program.Context.LoadAbilityScores(ImportExtensions.Fullpath(path, loaded.AbilityScores));
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show(e.Message + "\n" + e.InnerException + "\n" + e.StackTrace, "Error while Loading Configuration");
Program.Exit();
}
}
public static void LoadData()
{
Context.LoadPluginManager(Path.Combine(Application.StartupPath, Context.Config.Plugins_Directory));
Context.LoadLevel(ImportExtensions.Fullpath(Application.StartupPath, "Levels.xml"));
Context.ImportZips(false);
Context.ImportSkills(false);
Context.ImportLanguages(false);
Context.ImportSpells(false);
Context.ImportItems(false);
Context.ImportBackgrounds(false);
Context.ImportRaces(false);
Context.ImportSubRaces(false);
Context.ImportStandaloneFeatures(false);
Context.ImportConditions(false);
Context.ImportMagic(false);
Context.ImportClasses(false, true);
Context.ImportSubClasses(false, true);
foreach (ClassDefinition c in Context.Classes.Values)
{
c.ApplyKeywords(Context);
}
foreach (SubClass c in Context.SubClasses.Values)
{
c.ApplyKeywords(Context);
}
Context.ImportMonsters(false);
}
public static PDF Load(String file)
{
using (TextReader reader = new StreamReader(file))
{
PDF p = (PDF)PDF.Serializer.Deserialize(reader);
p.File = ImportExtensions.Fullpath(Path.GetDirectoryName(file), p.File);
p.SpellFile = ImportExtensions.Fullpath(Path.GetDirectoryName(file), p.SpellFile);
p.ActionsFile = ImportExtensions.Fullpath(Path.GetDirectoryName(file), p.ActionsFile);
p.ActionsFile2 = ImportExtensions.Fullpath(Path.GetDirectoryName(file), p.ActionsFile2);
p.LogFile = ImportExtensions.Fullpath(Path.GetDirectoryName(file), p.LogFile);
p.SpellbookFile = ImportExtensions.Fullpath(Path.GetDirectoryName(file), p.SpellbookFile);
return(p);
}
}
private void packToolStripMenuItem_Click(object sender, EventArgs e)
{
if (ItemCat.SelectedItem == null)
{
return;
}
Pack i = new Pack()
{
Source = Program.Context.Config.DefaultSource,
Category = ImportExtensions.Make(Program.Context, (string)ItemCat.SelectedItem)
};
PackForm r = new PackForm(i);
r.Saved += ItemSaved;
r.Show();
}
public static void LoadData()
{
Context.LoadPluginManager(Path.Combine(Application.StartupPath, Context.Config.Plugins_Directory));
Context.LoadLevel(ImportExtensions.Fullpath(Application.StartupPath, "Levels.xml"));
Context.ImportSkills();
Context.ImportLanguages();
Context.ImportSpells();
Context.ImportItems();
Context.ImportBackgrounds();
Context.ImportRaces();
Context.ImportSubRaces();
Context.ImportStandaloneFeatures();
Context.ImportConditions();
Context.ImportMagic();
Context.ImportClasses(true);
Context.ImportSubClasses(true);
}
private void ItemCats_SelectedIndexChanged(object sender, EventArgs e)
{
string cat = (string)ItemCat.SelectedItem;
ItemBox.Items.Clear();
NewItemCat.Enabled = false;
NewItem.Enabled = false;
if (cat != null)
{
NewItemCat.Enabled = true;
NewItem.Enabled = true;
Category category = ImportExtensions.Make(Program.Context, cat);
foreach (Item i in from i in Program.Context.Items.Values where category.Equals(i.Category) orderby i.Name select i)
{
ItemBox.Items.Add(i);
}
}
}
public static bool Save(this MagicProperty mp, Boolean overwrite)
{
mp.Name = mp.Name.Replace(ConfigManager.SourceSeperator, '-');
MagicProperty o = null;
if (Program.Context.Magic.ContainsKey(mp.Name + " " + ConfigManager.SourceSeperator + " " + mp.Source))
{
o = Program.Context.Magic[mp.Name + " " + ConfigManager.SourceSeperator + " " + mp.Source];
}
if (o != null && o.Category != mp.Category)
{
throw new Exception("Magic Property needs a unique name");
}
FileInfo file = SourceManager.GetFileName(mp.Name, mp.Source, ImportExtensions.MagicPropertyCleanname(Program.Context, mp.Category));
if (file.Exists && (mp.FileName == null || !mp.FileName.Equals(file.FullName)) && !overwrite)
{
return(false);
}
using (TextWriter writer = new StreamWriter(file.FullName)) MagicProperty.Serializer.Serialize(writer, mp);
mp.FileName = file.FullName;
return(true);
}
private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
{
TabPage tab = TabControls.SelectedTab;
if (tab == racesTab)
{
Program.Context.ImportRaces();
foreach (Race r in Program.Context.Races.Values)
{
CheckFeatures(r.Features, r.Name, r.Source);
}
Program.Context.ImportSubRaces();
foreach (SubRace r in Program.Context.SubRaces.Values)
{
CheckFeatures(r.Features, r.Name, r.Source);
}
fill(racesList, Program.Context.Races.Keys, null);
fill(subRaceList, Program.Context.SubRaces.Keys, null);
}
else if (tab == featuresTab)
{
Program.Context.ImportStandaloneFeatures();
foreach (List <FeatureContainer> rr in Program.Context.FeatureContainers.Values)
{
foreach (FeatureContainer r in rr)
{
CheckFeatures(r.Features, r.category + ":" + r.Name, r.Source);
}
}
FeatCats.Items.Clear();
FeatCats.Items.Add("Feats");
foreach (string s in ImportExtensions.EnumerateCategories(Program.Context, Program.Context.Config.Features_Directory))
{
FeatCats.Items.Add(s);
}
}
else if (tab == classesTab)
{
Program.Context.ImportClasses();
foreach (ClassDefinition r in Program.Context.Classes.Values)
{
CheckFeatures(r.Features, r.Name, r.Source);
CheckFeatures(r.MulticlassingFeatures, r.Name, r.Source);
CheckFeatures(r.FirstClassFeatures, r.Name, r.Source);
}
fill(classList, Program.Context.Classes.Keys, null);
Program.Context.ImportSubClasses();
foreach (SubClass r in Program.Context.SubClasses.Values)
{
CheckFeatures(r.Features, r.Name, r.Source);
CheckFeatures(r.MulticlassingFeatures, r.Name, r.Source);
CheckFeatures(r.FirstClassFeatures, r.Name, r.Source);
}
fill(subclassList, Program.Context.SubClasses.Keys, null);
}
else if (tab == langTab)
{
Program.Context.ImportLanguages();
fill(langBox, Program.Context.Languages.Keys, null);
}
else if (tab == backTab)
{
Program.Context.ImportBackgrounds();
foreach (Background r in Program.Context.Backgrounds.Values)
{
CheckFeatures(r.Features, r.Name, r.Source);
}
fill(backBox, Program.Context.Backgrounds.Keys, null);
}
else if (tab == itemTab)
{
Program.Context.ImportItems();
ItemCat.Items.Clear();
ItemCat.Items.Add("Items");
foreach (string s in ImportExtensions.EnumerateCategories(Program.Context, Program.Context.Config.Items_Directory))
{
ItemCat.Items.Add(s);
}
}
else if (tab == skillsTab)
{
Program.Context.ImportSkills();
fill(skillList, Program.Context.Skills.Keys, null);
}
else if (tab == conditionsTab)
{
Program.Context.ImportConditions();
fill(condList, Program.Context.Conditions.Keys, null);
}
else if (tab == monsterTab)
{
Program.Context.ImportMonsters();
fill(monsterbox, Program.Context.Monsters.Keys, null);
}
else if (tab == levelTab)
{
Level c = Program.Context.LoadLevel(Program.Context.Config.Levels);
LevelXP.Items = c.Experience;
LevelProficiency.Items = c.Proficiency;
}
else if (tab == arraysTab)
{
AbilityScores ab = Program.Context.LoadAbilityScores(Program.Context.Config.AbilityScores);
PointBuyPoints.DataBindings.Clear();
PointBuyPoints.DataBindings.Add("Value", ab, "PointBuyPoints", true, DataSourceUpdateMode.OnPropertyChanged);
PointBuyMin.DataBindings.Clear();
PointBuyMin.DataBindings.Add("Value", ab, "PointBuyMinScore", true, DataSourceUpdateMode.OnPropertyChanged);
PointBuyMax.DataBindings.Clear();
PointBuyMax.DataBindings.Add("Value", ab, "PointBuyMaxScore", true, DataSourceUpdateMode.OnPropertyChanged);
MaxScore.DataBindings.Clear();
MaxScore.DataBindings.Add("Value", ab, "DefaultMax", true, DataSourceUpdateMode.OnPropertyChanged);
PointBuyList.DataBindings.Clear();
PointBuyList.DataBindings.Add("Start", ab, "PointBuyMinScore", true, DataSourceUpdateMode.OnPropertyChanged);
PointBuyList.Items = ab.PointBuyCost;
Arrays.Items = ab.Arrays;
}
else if (tab == spellsTab)
{
Program.Context.ImportSpells();
fill(spellBox, Program.Context.Spells.Keys, null);
}
else if (tab == magicTab)
{
Program.Context.ImportMagic();
foreach (MagicProperty r in Program.Context.Magic.Values)
{
CheckFeatures(r.AttunedEquipFeatures, r.Name, r.Source);
CheckFeatures(r.AttunedOnUseFeatures, r.Name, r.Source);
CheckFeatures(r.AttunementFeatures, r.Name, r.Source);
CheckFeatures(r.CarryFeatures, r.Name, r.Source);
CheckFeatures(r.EquipFeatures, r.Name, r.Source);
CheckFeatures(r.OnUseFeatures, r.Name, r.Source);
}
magicCatBox.Items.Clear();
magicCatBox.Items.Add("Magic");
foreach (string s in ImportExtensions.EnumerateCategories(Program.Context, Program.Context.Config.Magic_Directory))
{
magicCatBox.Items.Add(s);
}
}
else if (tab == settingsTab)
{
DefaultSource.AutoCompleteCustomSource.Clear();
DefaultSource.AutoCompleteCustomSource.AddRange(SourceManager.Sources.ToArray());
}
}
static void Main(string[] args)
{
string server, projectId, username, password;
if (args == null || args.Length < 4)
{
Console.WriteLine("Missing arguments.");
return;
}
else
{
server = args[0];
projectId = args[1];
username = args[2];
password = args[3];
}
Console.WriteLine("----------------------NR CSV to API----------------------");
Console.WriteLine("Authenticating...");
DataAPIClient apiClient = new DataAPIClient(new System.Net.Http.HttpClient(), true)
{
BaseUri = new Uri(server)
};
apiClient.HttpClient.Timeout = Timeout.InfiniteTimeSpan;
//authorize
TokenResponse tokenResponse = AccountExtensions.GetToken(apiClient.Account, new TokenRequest(username, password));
apiClient.HttpClient.DefaultRequestHeaders.Authorization
= new AuthenticationHeaderValue("Bearer", tokenResponse.AccessToken);
if (tokenResponse.AccessToken == null || tokenResponse.AccessToken == "")
{
Console.WriteLine("AUTHENTICATION FAILED");
return;
}
else
{
Console.WriteLine("Authentication COMPLETED!");
}
Console.WriteLine("Mapping data from CSV...");
string filelocation = Path.Combine(Environment.CurrentDirectory + "\\..\\..\\Data\\csv\\test.csv");
//Mapping CSV data into C# object
List <CSVData> csvData = DataMapper.getMappedDataFromCSV(filelocation);
JSONModel uploadData = new JSONModel();
//Mapping MetaData for JSONModel
DataMapper.getMetadataForImport().ForEach(uploadData.MetaData.Add);
//Mapping CaseData for JSONModel
DataMapper.getCasedataForImport(csvData).ForEach(uploadData.CaseData.Add);
//Serializing JSONModel C# Object to JSON Object
var json = new JavaScriptSerializer().Serialize(uploadData);
Console.WriteLine("Mapping COMPLETED!");
//Import API of JSON Object data
Console.WriteLine("Importing data to the server");
dynamic importInput = json;
Response importResponse = ImportExtensions.PostImport(apiClient.Import, importInput, projectId);
if (importResponse.Data == null || tokenResponse.AccessToken == "")
{
Console.WriteLine("DATA IMPORT FAILED");
return;
}
else
{
Console.WriteLine("Import COMPLETED!");
}
//GET Import Batches API
PagedInputOfBatchFilterInput batchFilterInput = new PagedInputOfBatchFilterInput()
{
Paging = new PagingInput()
{
PageNumber = 1,
PageSize = 10
}
};
Response batches = ImportExtensions.Batches(apiClient.Import, batchFilterInput, projectId);
//Isolating ImportId for activation from batches.Data string
var Ids = batches.Data.ToString();
Ids = Ids.Substring(Ids.IndexOf("ImportID") + 11, Ids.Length - (Ids.IndexOf("ImportID") + 11));
Ids = Ids.Substring(0, Ids.IndexOf("\r") - 1);
string[] parsedIds = Ids.Split(',');
List <long?> IdsToActivates = new List <long?>();
foreach (string s in parsedIds)
{
if (Int32.TryParse(s, out int result))
{
IdsToActivates.Add(result);
}
}
Console.WriteLine("Activating data on the server...");
//Activate Import Batches API
ActivateInput activateInput = new ActivateInput()
{
IdsToActivate = IdsToActivates,
IdsToDeactivate = new List <long?>()
};
ActivationExtensions.Activate(apiClient.Activation, activateInput, projectId);
//GET Activation History API
PagedInputOfActivationHistoryFilterInput historyFilterInput = new PagedInputOfActivationHistoryFilterInput()
{
Paging = new PagingInput()
{
PageNumber = 1,
PageSize = 10
}
,
Sorting = new SortingInput()
{
OrderBy = "ActivationTime",
Ascending = false
}
};
Response activationHistory = ActivationExtensions.History(apiClient.Activation, historyFilterInput, projectId);
//Isolating last history record for valdiation
var history = activationHistory.Data.ToString();
history = history.Substring(history.IndexOf("ActivationTime") + 18, history.Length - (history.IndexOf("ActivationTime") + 18));
history = history.Substring(0, history.IndexOf("\r") - 3);
if (DateTime.TryParse(history, out DateTime lastHistory))
{
if (lastHistory > DateTime.Now.AddMinutes(-60))
{
Console.WriteLine("Data activation COMPLETED!");
}
else
{
Console.WriteLine("DATA ACTIVATION FAILED");
return;
}
}
else
{
Console.WriteLine("DATA ACTIVATION FAILED");
return;
}
}
