static bool IsValidCountryXMLFile(string folderPath, string countryShortName, out string errorMessage, bool checkForCountryConsistence = false)
{
try
{
CountryConfig countryConfig = new CountryConfig();
string fileName = EMPath.AddSlash(folderPath) + GetCountryXMLFileName(countryShortName);
if (!File.Exists(fileName))
{
errorMessage = string.Format($"File '{fileName}' not found."); return(false);
} // this is for whatever reason not catched by the error handler and leads to a crash if not handled here
using (StreamReader streamReader = new StreamReader(fileName, DefGeneral.DEFAULT_ENCODING))
countryConfig.ReadXml(streamReader);
//trying to access country leads to an exception if this is not a valid country xml-file
string xmlCountryShortName = countryConfig.Country.First().ShortName;
if (checkForCountryConsistence)
{
if (xmlCountryShortName.ToLower() != countryShortName.ToLower())
{
throw new System.ArgumentException("Name of country within file (" + xmlCountryShortName +
") does not correspond with name used for country file (" + countryShortName + ").");
}
}
errorMessage = string.Empty;
return(true);
}
catch (Exception exception)
{
errorMessage = exception.Message;
return(false);
}
}
internal static void GetExtensionContent(CountryConfigFacade countryConfigFacade, string extensionID,
out Dictionary <string, bool> policyInfo, out Dictionary <string, bool> functionInfo, out Dictionary <string, bool> parameterInfo)
{
CountryConfig countryConfig = countryConfigFacade.GetCountryConfig();
policyInfo = new Dictionary <string, bool>(); functionInfo = new Dictionary <string, bool>(); parameterInfo = new Dictionary <string, bool>();
foreach (var pe in countryConfig.Extension_Policy)
{
if (pe.ExtensionID == extensionID)
{
policyInfo.Add(pe.PolicyID, pe.BaseOff);
}
}
foreach (var fe in countryConfig.Extension_Function)
{
if (fe.ExtensionID == extensionID)
{
functionInfo.Add(fe.FunctionID, fe.BaseOff);
}
}
foreach (var pe in countryConfig.Extension_Parameter)
{
if (pe.ExtensionID == extensionID)
{
parameterInfo.Add(pe.ParameterID, pe.BaseOff);
}
}
}
public GameConfig()
{
kill_point_30_60 = new IntArray();
kill_point_60 = new IntArray();
delta_level_exp = new IntArray();
carriage_list = new IntArray();
best_carriage_list = new IntArray();
clear_cd_skill_list = new IntArray();
pickup_item_notice = new IntArray();
learn_skill = new LearnSkillConfig();
equip_endure_cost = new EquipEndureCost();
strings = new ConstString();
battlefield = new BattlefieldConfig();
jizhou_battlefield = new JiZhouBattlefieldConfig();
huangjin_battlefield = new HuangJinBattlefieldConfig();
card_mgr = new CardMgr();
group_setting = new GroupSetting();
store_setting = new IBStoreSettings();
relationship = new RelationshipConfig();
OfflineExpItems = new OfflineExpItemCfgArray();
OfflineExpPerLevels = new OfflineExpPerLevelArray();
group_league = new GroupLeagueConfig();
country = new CountryConfig();
auto_equip_when_enter_map_config = new AutoEquipWhenEnterMapConfig();
sign_manager = new SignManager();
}
internal override void PerformAction()
{
ExtensionAndGroupMenuManager.GetSelectionPolFunPar(cc, out List <CountryConfig.PolicyRow> polRows, out List <CountryConfig.FunctionRow> funRows, out List <CountryConfig.ParameterRow> parRows);
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(cc).GetCountryConfig();
CountryConfig.LookGroupRow groupRow = (from lg in countryConfig.LookGroup where lg.Name.ToLower() == groupName.ToLower() select lg).First();
foreach (CountryConfig.PolicyRow policyRow in polRows)
{
if (!(from pg in countryConfig.LookGroup_Policy where pg.PolicyID == policyRow.ID && pg.LookGroupID == groupRow.ID select pg).Any())
{
countryConfig.LookGroup_Policy.AddLookGroup_PolicyRow(groupRow, policyRow); // make sure to not add twice (and thus crash)
}
}
foreach (CountryConfig.FunctionRow functionRow in funRows)
{
if (!(from fg in countryConfig.LookGroup_Function where fg.FunctionID == functionRow.ID && fg.LookGroupID == groupRow.ID select fg).Any())
{
countryConfig.LookGroup_Function.AddLookGroup_FunctionRow(groupRow, functionRow);
}
}
foreach (CountryConfig.ParameterRow parameterRow in parRows)
{
if (!(from pg in countryConfig.LookGroup_Parameter where pg.ParameterID == parameterRow.ID && pg.LookGroupID == groupRow.ID select pg).Any())
{
countryConfig.LookGroup_Parameter.AddLookGroup_ParameterRow(groupRow, parameterRow);
}
}
}
internal override void PerformAction()
{
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(cc).GetCountryConfig();
ExtensionAndGroupMenuManager.GetSelectionPolFunPar(cc, out selectedPolRows, out selectedFunRows, out List <CountryConfig.ParameterRow> parRows);
string extensionID = (from e in ExtensionAndGroupManager.GetExtensions(cc) where e.Name == extensionName select e.ID).FirstOrDefault(); if (extensionID == null)
{
return;
}
List <CountryConfig.Extension_PolicyRow> delPolicyRows = new List <CountryConfig.Extension_PolicyRow>();
List <CountryConfig.Extension_FunctionRow> delFunctionRows = new List <CountryConfig.Extension_FunctionRow>();
List <CountryConfig.Extension_ParameterRow> delParameterRows = new List <CountryConfig.Extension_ParameterRow>();
foreach (CountryConfig.PolicyRow policyRow in selectedPolRows)
{
selectedFunRows.AddRange(policyRow.GetFunctionRows()); // to make sure that all functions of the policy are removed as well - note: the AddContent-function
// does not remove a single function if its parent-policy is added (later)
foreach (CountryConfig.Extension_PolicyRow del in from pe in countryConfig.Extension_Policy where pe.ExtensionID == extensionID& pe.PolicyID == policyRow.ID select pe)
{
if (!delPolicyRows.Contains(del))
{
delPolicyRows.Add(del); // theoretically (but stupidly) this can be 2 (off and on)
}
}
}
foreach (CountryConfig.FunctionRow functionRow in selectedFunRows)
{
parRows.AddRange(functionRow.GetParameterRows()); // see above
foreach (CountryConfig.Extension_FunctionRow del in from fe in countryConfig.Extension_Function where fe.ExtensionID == extensionID& fe.FunctionID == functionRow.ID select fe)
{
if (!delFunctionRows.Contains(del))
{
delFunctionRows.Add(del);
}
}
}
foreach (CountryConfig.ParameterRow parameterRow in parRows)
{
foreach (CountryConfig.Extension_ParameterRow del in from pe in countryConfig.Extension_Parameter where pe.ExtensionID == extensionID& pe.ParameterID == parameterRow.ID select pe)
{
if (!delParameterRows.Contains(del))
{
delParameterRows.Add(del);
}
}
}
for (int i = delPolicyRows.Count - 1; i >= 0; --i)
{
delPolicyRows[i].Delete();
}
for (int i = delFunctionRows.Count - 1; i >= 0; --i)
{
delFunctionRows[i].Delete();
}
for (int i = delParameterRows.Count - 1; i >= 0; --i)
{
delParameterRows[i].Delete();
}
}
private bool IsWholeContentPrivate(CountryConfig countryConfig, string ID)
{
foreach (CountryConfig.PolicyRow polRow in from ep in countryConfig.Extension_Policy where ep.ExtensionID == ID && !ep.BaseOff select ep.PolicyRow)
{
if (polRow.Private != DefPar.Value.YES)
{
return(false);
}
}
foreach (CountryConfig.FunctionRow funRow in from ef in countryConfig.Extension_Function where ef.ExtensionID == ID && !ef.BaseOff select ef.FunctionRow)
{
if (funRow.Private != DefPar.Value.YES)
{
return(false);
}
}
foreach (CountryConfig.ParameterRow parRow in from ep in countryConfig.Extension_Parameter where ep.ExtensionID == ID && !ep.BaseOff select ep.ParameterRow)
{
if (parRow.Private != DefPar.Value.YES)
{
return(false);
}
}
return(true);
}
internal static void GetLookGroupContent(CountryConfigFacade countryConfigFacade, string groupID,
out List <string> policyIDs, out List <string> functionIDs, out List <string> parameterIDs)
{
CountryConfig countryConfig = countryConfigFacade.GetCountryConfig();
policyIDs = (from pg in countryConfig.LookGroup_Policy where pg.LookGroupRow.ID.ToLower() == groupID.ToLower() select pg.PolicyID).ToList();
functionIDs = (from fg in countryConfig.LookGroup_Function where fg.LookGroupRow.ID.ToLower() == groupID.ToLower() select fg.FunctionID).ToList();
parameterIDs = (from pg in countryConfig.LookGroup_Parameter where pg.LookGroupRow.ID.ToLower() == groupID.ToLower() select pg.ParameterID).ToList();
}
private void CmbCountry_SelectedValueChanged(object sender, EventArgs e)
{
var senderComboBox = (ComboBox)sender;
SelectedCountryConfig = (CountryConfig)senderComboBox.SelectedItem;
var yearDataSourceList = ConfigList.Where(cl => cl.Country == SelectedCountryConfig.Country).Select(cl => cl.Year).ToList();
yearDataSourceList.Insert(0, "Select Year");
cmbYear.DataSource = yearDataSourceList;
}
internal override void PerformAction()
{
ExtensionAndGroupMenuManager.GetSelectionPolFunPar(cc, out List <CountryConfig.PolicyRow> polRows, out List <CountryConfig.FunctionRow> funRows, out List <CountryConfig.ParameterRow> parRows);
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(cc).GetCountryConfig();
CountryConfig.LookGroupRow groupRow = (from lg in countryConfig.LookGroup where lg.Name.ToLower() == groupName.ToLower() select lg).First();
List <CountryConfig.LookGroup_PolicyRow> delPolicyRows = new List <CountryConfig.LookGroup_PolicyRow>();
List <CountryConfig.LookGroup_FunctionRow> delFunctionRows = new List <CountryConfig.LookGroup_FunctionRow>();
List <CountryConfig.LookGroup_ParameterRow> delParameterRows = new List <CountryConfig.LookGroup_ParameterRow>();
foreach (CountryConfig.PolicyRow policyRow in polRows)
{
funRows.AddRange(policyRow.GetFunctionRows()); // to make sure that all functions of the policy are removed as well - note: the AddContent-function
// does not remove a single function if its parent-policy is added (later)
var del = from pg in countryConfig.LookGroup_Policy where pg.LookGroupID == groupRow.ID && pg.PolicyID == policyRow.ID select pg;
if (del.Any() && !delPolicyRows.Contains(del.First()))
{
delPolicyRows.Add(del.First());
}
}
foreach (CountryConfig.FunctionRow functionRow in funRows)
{
parRows.AddRange(functionRow.GetParameterRows()); // see above
var del = from fg in countryConfig.LookGroup_Function where fg.LookGroupID == groupRow.ID && fg.FunctionID == functionRow.ID select fg;
if (del.Any() && !delFunctionRows.Contains(del.First()))
{
delFunctionRows.Add(del.First());
}
}
foreach (CountryConfig.ParameterRow parameterRow in parRows)
{
var del = from pg in countryConfig.LookGroup_Parameter where pg.LookGroupID == groupRow.ID && pg.ParameterID == parameterRow.ID select pg;
if (del.Any() && !delParameterRows.Contains(del.First()))
{
delParameterRows.Add(del.First());
}
}
for (int i = delPolicyRows.Count - 1; i >= 0; --i)
{
delPolicyRows[i].Delete();
}
for (int i = delFunctionRows.Count - 1; i >= 0; --i)
{
delFunctionRows[i].Delete();
}
for (int i = delParameterRows.Count - 1; i >= 0; --i)
{
delParameterRows[i].Delete();
}
}
internal IsExtensionMember(CountryConfig countryConfig, DataConfig dataConfig, string extensionName, bool onOnly)
{
List <GlobLocExtensionRow> extensions = ExtensionAndGroupManager.GetExtensions((countryConfig.Country.Rows[0] as CountryConfig.CountryRow).ShortName);
string extensionID = (from e in extensions where e.Name == extensionName select e.ID).FirstOrDefault(); if (extensionID == null)
{
return;
}
policyIDs = (from pe in countryConfig.Extension_Policy where pe.ExtensionID == extensionID && (!onOnly || !pe.BaseOff) select pe.PolicyID).ToList();
functionIDs = (from fe in countryConfig.Extension_Function where fe.ExtensionID == extensionID && (!onOnly || !fe.BaseOff) select fe.FunctionID).ToList();
parameterIDs = (from pe in countryConfig.Extension_Parameter where pe.ExtensionID == extensionID && (!onOnly || !pe.BaseOff) select pe.ParameterID).ToList();
}
internal void SaveTable()
{
List <Tuple <string, string, string> > indTaxes = new List <Tuple <string, string, string> >();
foreach (DataGridViewRow row in table.Rows)
{
if (row.Cells[colName.Name].Value == null || string.IsNullOrEmpty(row.Cells[colName.Name].Value.ToString()))
{
continue; //probably an empty row
}
string name = row.Cells[colName.Name].Value == null ? string.Empty : row.Cells[colName.Name].Value.ToString();
string comment = row.Cells[colComment.Name].Value == null ? string.Empty : row.Cells[colComment.Name].Value.ToString();
string yearValues = string.Empty;
foreach (DataGridViewColumn yearColumn in GetYearColumnsAsDisplayed())
{
if (row.Cells[yearColumn.Index].Value != null)
{
yearValues += yearColumn.HeaderText + separatorYear + row.Cells[yearColumn.Index].Value.ToString();
}
yearValues += separator;
}
indTaxes.Add(new Tuple <string, string, string>(name, comment, yearValues.TrimEnd(new char[] { separator })));
}
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(mainForm.GetCountryShortName()).GetCountryConfig();
foreach (var indTax in indTaxes)
{
List <CountryConfig.IndirectTaxRow> its = (from it in countryConfig.IndirectTax where it.Name.ToLower() == indTax.Item1.ToLower() select it).ToList();
if (its.Count == 0)
{
countryConfig.IndirectTax.AddIndirectTaxRow(Guid.NewGuid().ToString(), indTax.Item1, indTax.Item2, indTax.Item3);
}
else
{
its[0].Name = indTax.Item1; its[0].Comment = indTax.Item2; its[0].YearValues = indTax.Item3;
}
}
List <string> itNames = (from i in indTaxes select i.Item1.ToLower()).ToList();
for (int i = countryConfig.IndirectTax.Count - 1; i >= 0; --i)
{
if (!itNames.Contains(countryConfig.IndirectTax[i].Name.ToLower()))
{
countryConfig.IndirectTax.ElementAt(i).Delete();
}
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Geographic Entities
ContinentConfig.SetEntityBuilder(modelBuilder.Entity <Continent>());
CountryConfig.SetEntityBuilder(modelBuilder.Entity <Country>());
RegionConfig.SetEntityBuilder(modelBuilder.Entity <Region>());
// Administrative Entities
AdminConfig.SetEntityBuilder(modelBuilder.Entity <Admin>());
EventConfig.SetEntityBuilder(modelBuilder.Entity <Event>());
// Measures Entities
SanitaryMeasureConfig.SetEntityBuilder(modelBuilder.Entity <SanitaryMeasure>());
ContainmentMeasureConfig.SetEntityBuilder(modelBuilder.Entity <ContainmentMeasure>());
CmByCountry.SetEntityBuilder(modelBuilder.Entity <CountryContainmentMeasures>());
SmByCountry.SetEntityBuilder(modelBuilder.Entity <CountrySanitaryMeasures>());
// Hospital Entities
HospitalConfig.SetEntityBuilder(modelBuilder.Entity <Hospital>());
HEmployeeConfig.SetEntityBuilder(modelBuilder.Entity <HospitalEmployee>());
MedicationConfig.SetEntityBuilder(modelBuilder.Entity <Medication>());
// Person Entities
PatientConfig.SetEntityBuilder(modelBuilder.Entity <Patient>());
P_MedicationConfig.SetEntityBuilder(modelBuilder.Entity <PatientMedications>());
Pt_PathologyConfig.SetEntityBuilder(modelBuilder.Entity <PatientPathologies>());
PersonConfig.SetEntityBuilder(modelBuilder.Entity <ContactedPerson>());
Ps_PathologyConfig.SetEntityBuilder(modelBuilder.Entity <PersonPathologies>());
ContactsByPatientConfig.SetEntityBuilder(modelBuilder.Entity <PersonsContactedByPatient>());
// Not related Entities
PathologiesConfig.SetEntityBuilder(modelBuilder.Entity <Pathology>());
Pharm_CompanyConfig.SetEntityBuilder(modelBuilder.Entity <PharmaceuticalCompany>());
StatusConfig.SetEntityBuilder(modelBuilder.Entity <PatientStatus>());
// Views and Stored Procedures
modelBuilder.Entity <PatientView>().HasNoKey().ToView(null);
modelBuilder.Entity <ExportPatient>().HasNoKey().ToView(null);
modelBuilder.Entity <CasesView>().HasNoKey().ToView(null);
modelBuilder.Entity <ReportView>().HasNoKey().ToView(null);
modelBuilder.Entity <MeasureView>().HasNoKey().ToView(null);
modelBuilder.Entity <MedicationView>().HasNoKey().ToView(null);
modelBuilder.Entity <PatientMedicationView>().HasNoKey().ToView(null);
modelBuilder.Entity <PathologyView>().HasNoKey().ToView(null);
modelBuilder.Entity <ContactView>().HasNoKey().ToView(null);
}
void LoadTableContent()
{
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(mainForm.GetCountryShortName()).GetCountryConfig();
keepUndoData = false;
dataTable.PrimaryKey = new DataColumn[] { dataTable.Columns.Add("ID", typeof(Int16)) };
dataTable.PrimaryKey[0].AutoIncrement = true;
dataTable.Columns.Add(colName.Name);
List <string> years = new List <string>();
foreach (CountryConfig.IndirectTaxRow itr in countryConfig.IndirectTax)
{
foreach (string year in DecomposeYearValues(itr.YearValues).Keys)
{
if (!years.Contains(year))
{
years.Add(year);
}
}
}
foreach (string year in years)
{
AddYearColumn(year);
}
dataTable.Columns.Add(colComment.Name);
foreach (CountryConfig.IndirectTaxRow itr in countryConfig.IndirectTax)
{
DataRow row = dataTable.Rows.Add();
row.SetField(colName.Name, itr.Name);
row.SetField(colComment.Name, itr.Comment);
foreach (var yv in DecomposeYearValues(itr.YearValues))
{
row.SetField(colYear + yv.Key.ToString(), yv.Value);
}
}
dataSet.AcceptChanges();
undoManager.AddDataSet(dataSet);
keepUndoData = true;
}
internal override void PerformAction()
{
string extensionID = (from e in ExtensionAndGroupManager.GetExtensions(cc) where e.Name.ToLower() == extensionName.ToLower() select e.ID).FirstOrDefault();
if (extensionID == null)
{
actionIsCanceled = true; return;
}
CountryConfigFacade countryConfigFacade = CountryAdministrator.GetCountryConfigFacade(cc);
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(cc).GetCountryConfig();
List <string> polIDs = (from pe in countryConfig.Extension_Policy where pe.ExtensionID == extensionID && pe.BaseOff == false select pe.PolicyID).ToList();
List <string> funIDs = (from fe in countryConfig.Extension_Function where fe.ExtensionID == extensionID && fe.BaseOff == false select fe.FunctionID).ToList();
List <string> parIDs = (from pe in countryConfig.Extension_Parameter where pe.ExtensionID == extensionID && pe.BaseOff == false select pe.ParameterID).ToList();
if (!polIDs.Any() && !funIDs.Any() && !polIDs.Any())
{
actionIsCanceled = true; return;
}
string yn = set ? DefPar.Value.YES : DefPar.Value.NO;
foreach (string polID in polIDs)
{
countryConfigFacade.GetPolicyRowByID(polID).Private = yn;
}
foreach (string funID in funIDs)
{
countryConfigFacade.GetFunctionRowByID(funID).Private = yn;
}
foreach (string parID in parIDs)
{
countryConfigFacade.GetParameterRowByID(parID).Private = yn;
}
}
internal override void PerformAction()
{
DataConfig dataConfig = CountryAdministrator.GetDataConfigFacade(cc).GetDataConfig();
List <ExtensionOrGroup> extensions = new List <ExtensionOrGroup>();
foreach (DataConfig.ExtensionRow ext in from e in dataConfig.Extension select e)
{
extensions.Add(new ExtensionOrGroup(ext));
}
using (AdminExtensionsOrGroupsForm adminDialog = new AdminExtensionsOrGroupsForm("Administrate Country Specific Extensions", extensions))
{
if (adminDialog.ShowDialog() == DialogResult.Cancel)
{
actionIsCanceled = true; return;
}
foreach (ExtensionOrGroup addEx in adminDialog.added)
{
dataConfig.Extension.AddExtensionRow(Guid.NewGuid().ToString(), addEx.name, addEx.shortName, addEx.look.ToXml());
}
foreach (ExtensionOrGroup changeEx in adminDialog.changed)
{
DataConfig.ExtensionRow exRow = (from e in dataConfig.Extension where e.ID == changeEx.id select e).First();
exRow.Name = changeEx.name; exRow.ShortName = changeEx.shortName; exRow.Look = changeEx.look.ToXml();
}
List <DataConfig.ExtensionRow> ex = (from e in dataConfig.Extension select e).ToList();
for (int i = ex.Count - 1; i >= 0; --i)
{
if (adminDialog.deletedIds.Contains(ex[i].ID))
{
ex[i].Delete();
}
}
// prepare for DoAfterCommitWork (updating tree)
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(cc).GetCountryConfig();
foreach (string polID in from ep in countryConfig.Extension_Policy where adminDialog.deletedIds.Contains(ep.ExtensionID) select ep.PolicyID)
{
delExPolRows.Add((from p in countryConfig.Policy where p.ID == polID select p).FirstOrDefault());
}
foreach (string funID in from ef in countryConfig.Extension_Function where adminDialog.deletedIds.Contains(ef.ExtensionID) select ef.FunctionID)
{
delExFunRows.Add((from f in countryConfig.Function where f.ID == funID select f).FirstOrDefault());
}
// deleteExtensionContent
List <CountryConfig.Extension_PolicyRow> delPolicyRows = new List <CountryConfig.Extension_PolicyRow>();
List <CountryConfig.Extension_FunctionRow> delFunctionRows = new List <CountryConfig.Extension_FunctionRow>();
List <CountryConfig.Extension_ParameterRow> delParameterRows = new List <CountryConfig.Extension_ParameterRow>();
foreach (string extensionID in adminDialog.deletedIds)
{
delPolicyRows.AddRange((from pe in countryConfig.Extension_Policy where pe.ExtensionID == extensionID select pe).ToList());
delFunctionRows.AddRange((from fe in countryConfig.Extension_Function where fe.ExtensionID == extensionID select fe).ToList());
delParameterRows.AddRange((from pe in countryConfig.Extension_Parameter where pe.ExtensionID == extensionID select pe).ToList());
}
for (int i = delPolicyRows.Count - 1; i >= 0; --i)
{
delPolicyRows[i].Delete();
}
for (int i = delFunctionRows.Count - 1; i >= 0; --i)
{
delFunctionRows[i].Delete();
}
for (int i = delParameterRows.Count - 1; i >= 0; --i)
{
delParameterRows[i].Delete();
}
}
}
internal static void CopyExtensionAndGroupMemberships(CountryConfig cc, string newSysID, string oldSysID)
{
// all policies belonging to any extension
List <Tuple <string, CountryConfig.PolicyRow, bool> > newExtPols = new List <Tuple <string, CountryConfig.PolicyRow, bool> >();
foreach (var ePol in from ep in cc.Extension_Policy where ep.PolicyRow.SystemID == oldSysID select ep)
{
newExtPols.Add(new Tuple <string, CountryConfig.PolicyRow, bool>(ePol.ExtensionID,
CountryConfigFacade.GetTwinRow(ePol.PolicyRow, newSysID) as CountryConfig.PolicyRow, ePol.BaseOff));
}
foreach (var newExtPol in newExtPols)
{
cc.Extension_Policy.AddExtension_PolicyRow(newExtPol.Item1, newExtPol.Item2, newExtPol.Item3);
}
// all functions belonging to any extension
List <Tuple <string, CountryConfig.FunctionRow, bool> > newExtFuns = new List <Tuple <string, CountryConfig.FunctionRow, bool> >();
foreach (var eFun in from ef in cc.Extension_Function where ef.FunctionRow.PolicyRow.SystemID == oldSysID select ef)
{
newExtFuns.Add(new Tuple <string, CountryConfig.FunctionRow, bool>(eFun.ExtensionID,
CountryConfigFacade.GetTwinRow(eFun.FunctionRow, newSysID) as CountryConfig.FunctionRow, eFun.BaseOff));
}
foreach (var newExtFun in newExtFuns)
{
cc.Extension_Function.AddExtension_FunctionRow(newExtFun.Item1, newExtFun.Item2, newExtFun.Item3);
}
// all parameters belonging to any extension
List <Tuple <string, CountryConfig.ParameterRow, bool> > newExtPars = new List <Tuple <string, CountryConfig.ParameterRow, bool> >();
foreach (var ePar in from ep in cc.Extension_Parameter where ep.ParameterRow.FunctionRow.PolicyRow.SystemID == oldSysID select ep)
{
newExtPars.Add(new Tuple <string, CountryConfig.ParameterRow, bool>(ePar.ExtensionID,
CountryConfigFacade.GetTwinRow(ePar.ParameterRow, newSysID) as CountryConfig.ParameterRow, ePar.BaseOff));
}
foreach (var newExtPar in newExtPars)
{
cc.Extension_Parameter.AddExtension_ParameterRow(newExtPar.Item1, newExtPar.Item2, newExtPar.Item3);
}
// all policies belonging to any group
List <Tuple <CountryConfig.LookGroupRow, CountryConfig.PolicyRow> > newGroupPols = new List <Tuple <CountryConfig.LookGroupRow, CountryConfig.PolicyRow> >();
foreach (var gPol in from gp in cc.LookGroup_Policy where gp.PolicyRow.SystemID == oldSysID select gp)
{
newGroupPols.Add(new Tuple <CountryConfig.LookGroupRow, CountryConfig.PolicyRow>(gPol.LookGroupRow,
CountryConfigFacade.GetTwinRow(gPol.PolicyRow, newSysID) as CountryConfig.PolicyRow));
}
foreach (var newGroupPol in newGroupPols)
{
cc.LookGroup_Policy.AddLookGroup_PolicyRow(newGroupPol.Item1, newGroupPol.Item2);
}
// all functions belonging to any group
List <Tuple <CountryConfig.LookGroupRow, CountryConfig.FunctionRow> > newGroupFuns = new List <Tuple <CountryConfig.LookGroupRow, CountryConfig.FunctionRow> >();
foreach (var gFun in from gf in cc.LookGroup_Function where gf.FunctionRow.PolicyRow.SystemID == oldSysID select gf)
{
newGroupFuns.Add(new Tuple <CountryConfig.LookGroupRow, CountryConfig.FunctionRow>(gFun.LookGroupRow,
CountryConfigFacade.GetTwinRow(gFun.FunctionRow, newSysID) as CountryConfig.FunctionRow));
}
foreach (var newGroupFun in newGroupFuns)
{
cc.LookGroup_Function.AddLookGroup_FunctionRow(newGroupFun.Item1, newGroupFun.Item2);
}
// all parameters belonging to any group
List <Tuple <CountryConfig.LookGroupRow, CountryConfig.ParameterRow> > newGroupPars = new List <Tuple <CountryConfig.LookGroupRow, CountryConfig.ParameterRow> >();
foreach (var gPar in from gp in cc.LookGroup_Parameter where gp.ParameterRow.FunctionRow.PolicyRow.SystemID == oldSysID select gp)
{
newGroupPars.Add(new Tuple <CountryConfig.LookGroupRow, CountryConfig.ParameterRow>(gPar.LookGroupRow,
CountryConfigFacade.GetTwinRow(gPar.ParameterRow, newSysID) as CountryConfig.ParameterRow));
}
foreach (var newGroupPar in newGroupPars)
{
cc.LookGroup_Parameter.AddLookGroup_ParameterRow(newGroupPar.Item1, newGroupPar.Item2);
}
}
internal override void PerformAction()
{
CountryConfig countryConfig = CountryAdministrator.GetCountryConfigFacade(cc).GetCountryConfig();
ExtensionAndGroupMenuManager.GetSelectionPolFunPar(cc, out List <CountryConfig.PolicyRow> polRows, out List <CountryConfig.FunctionRow> funRows, out List <CountryConfig.ParameterRow> parRows);
string extensionID = (from e in ExtensionAndGroupManager.GetExtensions(cc) where e.Name == extensionName select e.ID).FirstOrDefault(); if (extensionID == null)
{
return;
}
bool baseOff = !on;
foreach (CountryConfig.PolicyRow polRow in polRows)
{
if (!(from pe in countryConfig.Extension_Policy where pe.PolicyID == polRow.ID && pe.ExtensionID == extensionID && pe.BaseOff == baseOff select pe).Any())
{
countryConfig.Extension_Policy.AddExtension_PolicyRow(extensionID, polRow, baseOff); // make sure to not add twice (and thus crash)
if (polRow.Switch == DefPar.Value.NA)
{
polRow.Switch = DefPar.Value.OFF; // if set to n/a the xml-reader would ignore the policy, before extensions are taken into account
}
}
}
foreach (CountryConfig.FunctionRow funRow in funRows)
{
if (!(from fe in countryConfig.Extension_Function where fe.FunctionID == funRow.ID && fe.ExtensionID == extensionID && fe.BaseOff == baseOff select fe).Any())
{
countryConfig.Extension_Function.AddExtension_FunctionRow(extensionID, funRow, baseOff);
if (funRow.Switch == DefPar.Value.NA)
{
funRow.Switch = DefPar.Value.OFF;
}
}
}
foreach (CountryConfig.ParameterRow parRow in parRows)
{
if (!(from pe in countryConfig.Extension_Parameter where pe.ParameterID == parRow.ID && pe.ExtensionID == extensionID && pe.BaseOff == baseOff select pe).Any())
{
countryConfig.Extension_Parameter.AddExtension_ParameterRow(extensionID, parRow, baseOff);
}
}
if (!on)
{
return;
}
// adapt switches in treelist directly, as a full update takes too long
foreach (CountryConfig.PolicyRow polRow in polRows)
{
SetSwitch(polRow.ID, polRow.SystemID, false, DefPar.Value.SWITCH);
// for functions, which are part of an extension-policy one still needs to show off and n/a instead of switch (see GetExtensionAdaptedSwitch)
foreach (CountryConfig.FunctionRow funRow in polRow.GetFunctionRows())
{
SetSwitch(funRow.ID, polRow.SystemID, true, ExtensionAndGroupManager.GetExtensionAdaptedSwitch(funRow));
}
}
foreach (CountryConfig.FunctionRow funRow in funRows)
{
SetSwitch(funRow.ID, funRow.PolicyRow.SystemID, true, DefPar.Value.SWITCH);
}
void SetSwitch(string rowID, string sysID, bool isFun, string switchValue)
{
KeyValuePair <TreeListNode, TreeListColumn> cell = mainForm.GetTreeListBuilder().GetCellByDataRow(rowID, sysID, isFun);
if (cell.Key != null && cell.Value != null)
{
cell.Key.SetValue(cell.Value, switchValue);
}
}
}
internal IsGroupMember(CountryConfig countryConfig, string groupName)
{
policyIDs = (from pg in countryConfig.LookGroup_Policy where pg.LookGroupRow.Name.ToLower() == groupName.ToLower() select pg.PolicyID).ToList();
functionIDs = (from fg in countryConfig.LookGroup_Function where fg.LookGroupRow.Name.ToLower() == groupName.ToLower() select fg.FunctionID).ToList();
parameterIDs = (from pg in countryConfig.LookGroup_Parameter where pg.LookGroupRow.Name.ToLower() == groupName.ToLower() select pg.ParameterID).ToList();
}
public PreferredTableParser(string inputFile, CountryConfig configVar)
{
InputFile = inputFile;
CountryConfigVariable = configVar;
}
