/// <summary>add GeneratedReadSetControls</summary>
public override void ApplyDerivedFunctionality(TFormWriter writer, TControlDef control)
{
string controlName = control.xmlNode.Name;
writer.Template.AddToCodelet("INITIALISESCREEN",
controlName + ".InitialiseData(FPetraUtilsObject);" +
Environment.NewLine);
if (!(TYml2Xml.HasAttribute(control.xmlNode, "NoParameter") && (TYml2Xml.GetAttribute(control.xmlNode, "NoParameter").ToLower() == "true")))
{
writer.Template.AddToCodelet("READCONTROLS",
controlName + ".ReadControls(ACalc, AReportAction);" +
Environment.NewLine);
writer.Template.AddToCodelet("SETCONTROLS",
controlName + ".SetControls(AParameters);" +
Environment.NewLine);
}
writer.Template.AddToCodelet("SETAVAILABLEFUNCTIONS",
controlName + ".SetAvailableFunctions(FPetraUtilsObject.GetAvailableFunctions());" +
Environment.NewLine);
}
/// <summary>write the code for the designer file where the properties of the control are written</summary>
public override ProcessTemplate SetControlProperties(TFormWriter writer, TControlDef ctrl)
{
base.SetControlProperties(writer, ctrl);
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "PositiveValueActivates"))
{
if (ctrl.HasAttribute("OnChange"))
{
throw new Exception(ctrl.controlName + " cannot have OnChange and PositiveValueActivates at the same time");
}
AssignEventHandlerToControl(writer, ctrl, "ValueChanged", ctrl.controlName + "ValueChanged");
writer.CodeStorage.FEventHandlersImplementation +=
"private void " + ctrl.controlName + "ValueChanged" +
"(object sender, EventArgs e)" + Environment.NewLine +
"{" + Environment.NewLine +
" ActionEnabledEvent(null, new ActionEventArgs(\"" + TYml2Xml.GetAttribute(ctrl.xmlNode, "PositiveValueActivates") +
"\", " + ctrl.controlName + ".Value > 0));" + Environment.NewLine +
"}" + Environment.NewLine + Environment.NewLine;
}
return(writer.FTemplate);
}
/// <summary>
/// process the children
/// </summary>
public override void ProcessChildren(TFormWriter writer, TControlDef container)
{
// usually, the toolbar buttons are direct children of the toolbar control
List <XmlNode> childrenlist = TYml2Xml.GetChildren(container.xmlNode, true);
foreach (XmlNode childNode in childrenlist)
{
/* Get unique name if we need it
* at the moment we need it only for menu separators
*/
String UniqueChildName = childNode.Name;
TControlDef childCtrl = container.FCodeStorage.GetControl(childNode.Name);
if (childCtrl == null)
{
UniqueChildName = TYml2Xml.GetAttribute(childNode, "UniqueName");
childCtrl = container.FCodeStorage.GetControl(UniqueChildName);
}
container.Children.Add(childCtrl);
IControlGenerator ctrlGenerator = writer.FindControlGenerator(childCtrl);
ctrlGenerator.GenerateControl(writer, childCtrl);
}
}
/// <summary>
/// get the correct control generator for the control, depending on the prefix of the name, and other parameters
/// </summary>
/// <param name="ACtrlDef"></param>
/// <returns></returns>
public IControlGenerator FindControlGenerator(TControlDef ACtrlDef)
{
IControlGenerator fittingGenerator = null;
if (ACtrlDef.controlGenerator != null)
{
return(ACtrlDef.controlGenerator);
}
foreach (IControlGenerator generator in AvailableControlGenerators)
{
if (generator.ControlFitsNode(ACtrlDef.xmlNode))
{
if (fittingGenerator != null)
{
throw new Exception(
"Error: control with name " + ACtrlDef.xmlNode.Name + " does fit both control generators " +
fittingGenerator.ControlType +
" and " +
generator.ControlType);
}
fittingGenerator = generator;
}
}
if ((fittingGenerator == null) &&
(!ACtrlDef.controlName.StartsWith("Empty")))
{
if (TYml2Xml.HasAttribute(ACtrlDef.xmlNode, "Type") && (FBaseControlGeneratorType != null))
{
return((IControlGenerator)Activator.CreateInstance(FBaseControlGeneratorType, new Object[] { ACtrlDef.xmlNode.Name.Substring(0,
3),
TYml2Xml.GetAttribute(ACtrlDef.
xmlNode, "Type") }));
}
throw new Exception("Error: cannot find a generator for control with name " + ACtrlDef.xmlNode.Name);
}
ACtrlDef.controlGenerator = fittingGenerator;
return(fittingGenerator);
}
private static string GetCaption(XmlNode ANode)
{
return(Catalog.GetString(TYml2Xml.HasAttribute(ANode, "Label") ? TYml2Xml.GetAttribute(ANode,
"Label") : StringHelper.ReverseUpperCamelCase(ANode.Name)).Replace("&", ""));
}
/// <summary>
/// get value of attribute from yaml
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public string GetAttribute(string name)
{
return(TYml2Xml.GetAttribute(xmlNode, name));
}
/// parse basic things: BaseClass, FormTitle, Namespace
public void LoadFormProperties(XmlNode formNode)
{
string ModuleForSecurity;
FCodeStorage.FBaseClass = TYml2Xml.GetAttribute(formNode, "BaseClass");
FCodeStorage.FInterfaceName = TYml2Xml.GetAttribute(formNode, "InterfaceName");
FCodeStorage.FUtilObjectClass = TYml2Xml.GetAttribute(formNode, "UtilObjectClass");
FCodeStorage.FFormTitle = TYml2Xml.GetAttribute(formNode, "FormTitle");
FCodeStorage.FNamespace = TYml2Xml.GetAttribute(formNode, "Namespace");
FCodeStorage.FTemplate = TYml2Xml.GetAttribute(formNode, "Template");
if (TYml2Xml.HasAttribute(formNode, "ModuleForSecurity"))
{
FCodeStorage.FModuleForSecurity = TYml2Xml.GetAttribute(formNode, "ModuleForSecurity");
}
else
{
if (FCodeStorage.FNamespace != String.Empty)
{
// Attempt to find out the Module ('MPartner', 'MPersonnel', etc.) between 'Ict.Petra.Client.' and '.xxx'
ModuleForSecurity = FCodeStorage.FNamespace.Substring("Ict.Petra.Client.".Length);
if (!ModuleForSecurity.StartsWith("MReporting"))
{
if (ModuleForSecurity.IndexOf('.') != -1)
{
ModuleForSecurity = ModuleForSecurity.Substring(0, ModuleForSecurity.IndexOf('.'));
if (ModuleForSecurity != String.Empty)
{
FCodeStorage.FModuleForSecurity = ModuleForSecurity;
}
}
}
else
{
if (FCodeStorage.FNamespace.Length > "Ict.Petra.Client.MReporting.Gui.".Length)
{
// Attempt to find out the Module ('MPartner', 'MPersonnel', etc.) after 'Ict.Petra.Client.MReporting.Gui.'
ModuleForSecurity = FCodeStorage.FNamespace.Substring("Ict.Petra.Client.MReporting.Gui.".Length);
if (ModuleForSecurity != String.Empty)
{
FCodeStorage.FModuleForSecurity = ModuleForSecurity;
}
}
}
}
}
if (TYml2Xml.HasAttribute(formNode, "ModuleForSecurityDerminedByContext"))
{
FCodeStorage.FModuleForSecurityDerminedByContext = true;
}
// Check whether a form should automatically execute FPetraUtilsObject.ApplySecurity or not
if (TYml2Xml.HasAttribute(formNode, "AutomaticApplySecurityExecution") &&
(TYml2Xml.GetAttribute(formNode, "AutomaticApplySecurityExecution").ToLower() == "false"))
{
FCodeStorage.FAutomaticApplySecurityExecution = false;
}
if ((FCodeStorage.FBaseClass == "System.Windows.Forms.UserControl") ||
(FCodeStorage.FBaseClass == "TGrpCollapsible"))
{
FCodeStorage.FClassName = "T" + Path.GetFileNameWithoutExtension(FCodeStorage.FFilename);
}
else
{
FCodeStorage.FClassName = "TFrm" + Path.GetFileNameWithoutExtension(FCodeStorage.FFilename);
}
if (FCodeStorage.HasAttribute("ClassName"))
{
FCodeStorage.FClassName = FCodeStorage.GetAttribute("ClassName");
}
if (TYml2Xml.HasAttribute(formNode, "WindowHeight"))
{
FCodeStorage.FHeight = Convert.ToInt32(TYml2Xml.GetAttribute(formNode, "WindowHeight"));
}
if (TYml2Xml.HasAttribute(formNode, "WindowWidth"))
{
FCodeStorage.FWidth = Convert.ToInt32(TYml2Xml.GetAttribute(formNode, "WindowWidth"));
}
if (TYml2Xml.HasAttribute(formNode, "Height") || TYml2Xml.HasAttribute(formNode, "Width"))
{
TLogging.Log("Warning: Please use WindowWidth and WindowHeight, because Width and Height for the root node are invalid");
}
}
/// <summary>write the code for the designer file where the properties of the control are written</summary>
public override ProcessTemplate SetControlProperties(TFormWriter writer, TControlDef ctrl)
{
if (!ctrl.HasAttribute("Width"))
{
ctrl.SetAttribute("Width", FDefaultWidth.ToString());
}
base.SetControlProperties(writer, ctrl);
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".CancelEditingWithEscapeKey = false;" + Environment.NewLine);
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "SelectedRowActivates"))
{
// TODO: this function needs to be called by the manual code at the moment when eg a search finishes
// TODO: call "Activate" + TYml2Xml.GetAttribute(ctrl.xmlNode, "SelectedRowActivates")
}
StringCollection Columns = TYml2Xml.GetElements(ctrl.xmlNode, "Columns");
if (Columns.Count > 0)
{
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".Columns.Clear();" + Environment.NewLine);
//This needs to come immediately after the Columns.Clear() and before the creation of the columns
if (ctrl.HasAttribute("SortableHeaders"))
{
string trueOrFalse = ctrl.GetAttribute("SortableHeaders");
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".SortableHeaders = " + trueOrFalse + ";" + Environment.NewLine);
}
bool isFirstColumnVarchar = false;
bool doneFirstColumn = false;
foreach (string ColumnFieldName in Columns)
{
bool IsDetailNotMaster;
TTableField field = null;
string TableFieldTable;
string ColumnFieldNameResolved;
// customfield, eg. UC_GLTransactions, ATransaction.DateEntered and ATransaction.AnalysisAttributes
// there needs to be a list of CustomColumns
XmlNode CustomColumnsNode = TYml2Xml.GetChild(ctrl.xmlNode, "CustomColumns");
XmlNode CustomColumnNode = null;
if (CustomColumnsNode != null)
{
CustomColumnNode = TYml2Xml.GetChild(CustomColumnsNode, ColumnFieldName);
}
if ((ctrl.controlName == "grdDetails") && FCodeStorage.HasAttribute("DetailTable"))
{
TableFieldTable = FCodeStorage.GetAttribute("DetailTable");
if (ColumnFieldName.StartsWith("Detail") && !IsLegitimateDetailFieldName(TableFieldTable, ColumnFieldName))
{
ColumnFieldNameResolved = ColumnFieldName.Substring(6); // Drop 'Details' out of 'Details...'
}
else
{
ColumnFieldNameResolved = ColumnFieldName;
}
}
else
{
TableFieldTable = ctrl.GetAttribute("TableName");
ColumnFieldNameResolved = ColumnFieldName;
}
if (CustomColumnNode != null)
{
TTableField tf = null;
// if grd has no TableName property
if ((TableFieldTable == "") && ColumnFieldNameResolved.Contains("."))
{
int Period = ColumnFieldNameResolved.IndexOf(".");
string TableName = ColumnFieldNameResolved.Remove(Period);
string ColumnName = ColumnFieldNameResolved.Remove(0, TableName.Length + 1);
AddColumnToGrid(writer, ctrl.controlName,
TYml2Xml.GetAttribute(CustomColumnNode, "Type"),
TYml2Xml.GetAttribute(CustomColumnNode, "Label"),
TYml2Xml.GetAttribute(CustomColumnNode, "Tooltip"),
TableName,
ColumnName);
tf = TDataBinding.GetTableField(null, TableName + "." + ColumnName, out IsDetailNotMaster, true);
}
else
{
AddColumnToGrid(writer, ctrl.controlName,
TYml2Xml.GetAttribute(CustomColumnNode, "Type"),
TYml2Xml.GetAttribute(CustomColumnNode, "Label"),
TYml2Xml.GetAttribute(CustomColumnNode, "Tooltip"),
TableFieldTable,
ColumnFieldNameResolved);
tf = TDataBinding.GetTableField(null, TableFieldTable + "." + ColumnFieldNameResolved, out IsDetailNotMaster, true);
}
if (!doneFirstColumn)
{
isFirstColumnVarchar = tf.strName.EndsWith("_c");
doneFirstColumn = true;
}
}
else if (ctrl.HasAttribute("TableName"))
{
field = TDataBinding.GetTableField(null, ctrl.GetAttribute("TableName") + "." + ColumnFieldName,
out IsDetailNotMaster, true);
}
else
{
field = TDataBinding.GetTableField(null, ColumnFieldName, out IsDetailNotMaster, true);
}
if (field != null)
{
AddColumnToGrid(writer, ctrl.controlName,
field.iDecimals == 10 && field.iLength == 24 ? "Decimal" : field.GetDotNetType(),
field.strLabel.Length > 0 ? field.strLabel : field.strName,
String.Empty,
TTable.NiceTableName(field.strTableName),
TTable.NiceFieldName(field.strName));
if (!doneFirstColumn)
{
isFirstColumnVarchar = field.strName.EndsWith("_c");
doneFirstColumn = true;
}
}
}
if (FControlType == TYPE_DATA_GRID_NON_PAGED)
{
// Grid AutoFind definition (not allowed in paged grids)
string autoFindStr = ctrl.controlName + ".AutoFindMode = TAutoFindModeEnum.";
string mode = "NoAutoFind";
if (ctrl.HasAttribute("AutoFindMode"))
{
// Use the specified value in YAML
mode = ctrl.GetAttribute("AutoFindMode");
TLogging.Log("Info: AutoFindMode (with columns) was set to " + mode + " from explicit YAML attribute: " + ctrl.controlName);
}
else if (isFirstColumnVarchar)
{
// We can use auto-find because we have a first column based on a varchar
mode = "FirstCharacter";
TLogging.Log("Info: AutoFindMode (with columns) was set implicitly for: " + ctrl.controlName);
}
else
{
TLogging.Log("Info: AutoFindMode (with columns) was set to NoAutoFind for: " + ctrl.controlName);
}
writer.Template.AddToCodelet("INITMANUALCODE", autoFindStr + mode + ";" + Environment.NewLine);
if (ctrl.HasAttribute("AutoFindColumn"))
{
string colNum = ctrl.GetAttribute("AutoFindColumn");
writer.Template.AddToCodelet("INITMANUALCODE",
ctrl.controlName + ".AutoFindColumn = " + colNum + ";" + Environment.NewLine);
TLogging.Log("Info: AutoFindColumn was set to " + colNum + " for: " + ctrl.controlName);
}
if ((mode == "FirstCharacter") && !ctrl.HasAttribute("SortOrder"))
{
TLogging.Log("Info: AutoFind has been turned on for a grid with no YAML-defined sort order: (" + ctrl.controlName +
"). You can remove this message by explicitly setting a SortOrder in the YAML file.");
}
}
}
else
{
//If no columns, but the user is able to add columns dynamically during the running of the form, then need this here.
if (ctrl.HasAttribute("SortableHeaders"))
{
string trueOrFalse = ctrl.GetAttribute("SortableHeaders");
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".SortableHeaders = " + trueOrFalse + ";" + Environment.NewLine);
}
if (FControlType == TYPE_DATA_GRID_NON_PAGED)
{
// Grid AutoFind definition (not allowed in paged grids)
string autoFindStr = ctrl.controlName + ".AutoFindMode = TAutoFindModeEnum.";
string mode = "FirstCharacter";
if (ctrl.HasAttribute("AutoFindMode"))
{
// Use the specified value in YAML
mode = ctrl.GetAttribute("AutoFindMode");
TLogging.Log("Info: AutoFindMode (without columns) was set to " + mode + " from explicit YAML attribute: " + ctrl.controlName);
}
else if (writer.FCodeStorage.ManualFileExistsAndContains(ctrl.controlName + ".AddTextColumn("))
{
// We presume can use auto-find because we have a column (maybe the first) based on a varchar
TLogging.Log("Info: AutoFindMode (without columns) was set implicitly for: " + ctrl.controlName);
}
else
{
mode = "NoAutoFind";
TLogging.Log("Info: AutoFindMode (without columns) was set to NoAutoFind for: " + ctrl.controlName);
}
writer.Template.AddToCodelet("INITMANUALCODE", autoFindStr + mode + ";" + Environment.NewLine);
if (ctrl.HasAttribute("AutoFindColumn"))
{
string colNum = ctrl.GetAttribute("AutoFindColumn");
writer.Template.AddToCodelet("INITMANUALCODE",
ctrl.controlName + ".AutoFindColumn = " + colNum + ";" + Environment.NewLine);
TLogging.Log("Info: AutoFindColumn was set to " + colNum + " for: " + ctrl.controlName);
}
}
}
if (ctrl.controlName != "grdDetails")
{
if (ctrl.HasAttribute("ActionLeavingRow"))
{
AssignEventHandlerToControl(writer, ctrl, "Selection.FocusRowLeaving", "SourceGrid.RowCancelEventHandler",
ctrl.GetAttribute("ActionLeavingRow"));
}
if (ctrl.HasAttribute("ActionFocusRow"))
{
AssignEventHandlerToControl(writer, ctrl, "Selection.FocusRowEntered", "SourceGrid.RowEventHandler",
ctrl.GetAttribute("ActionFocusRow"));
}
}
if (ctrl.HasAttribute("ActionEnterKeyPressed"))
{
AssignEventHandlerToControl(writer, ctrl, "EnterKeyPressed", "TKeyPressedEventHandler",
ctrl.GetAttribute("ActionEnterKeyPressed"));
}
if ((ctrl.controlName == "grdDetails") && FCodeStorage.HasAttribute("DetailTable"))
{
writer.Template.AddToCodelet("SHOWDATA", "");
if (ctrl.HasAttribute("SortOrder"))
{
// SortOrder is comma separated and has DESC or ASC after the column name
string SortOrder = ctrl.GetAttribute("SortOrder");
foreach (string SortOrderPart in SortOrder.Split(','))
{
bool temp;
TTableField field = null;
string columnNamePart = SortOrderPart.Split(' ')[0];
if ((columnNamePart.IndexOf(".") == -1) && ctrl.HasAttribute("TableName"))
{
field = TDataBinding.GetTableField(null, ctrl.GetAttribute("TableName") + "." + columnNamePart, out temp, true);
}
else
{
field = TDataBinding.GetTableField(null, columnNamePart, out temp, true);
}
if (field != null)
{
SortOrder = SortOrder.Replace(columnNamePart, field.strName);
}
}
writer.Template.AddToCodelet("GRIDSORT", SortOrder);
}
if (ctrl.HasAttribute("RowFilter"))
{
// this references a field in the table, and assumes there exists a local variable with the same name
// eg. FBatchNumber in GL Journals
string RowFilter = ctrl.GetAttribute("RowFilter");
String FilterString = "\"";
foreach (string RowFilterPart in RowFilter.Split(','))
{
bool temp;
string columnName =
TDataBinding.GetTableField(
null,
RowFilterPart,
out temp, true).strName;
if (FilterString.Length > 1)
{
FilterString += " + \" and ";
}
FilterString += columnName + " = \" + F" + TTable.NiceFieldName(columnName) + ".ToString()";
}
writer.Template.AddToCodelet("GRIDFILTER", FilterString);
}
}
if (ctrl.controlName == "grdDetails")
{
if (ctrl.HasAttribute("EnableMultiSelection"))
{
writer.Template.SetCodelet("GRIDMULTISELECTION",
String.Format("grdDetails.Selection.EnableMultiSelection = {0};{1}", ctrl.GetAttribute("EnableMultiSelection"),
Environment.NewLine));
}
else if (FCodeStorage.FControlList.ContainsKey("btnDelete"))
{
writer.Template.SetCodelet("GRIDMULTISELECTION",
"grdDetails.Selection.EnableMultiSelection = true;" + Environment.NewLine);
}
}
return(writer.FTemplate);
}
/// <summary>
/// Execute action from the navigation tree.
/// </summary>
/// <returns>The error or status message.</returns>
public static string ExecuteAction(XmlNode node, Form AParentWindow)
{
bool FormWasAlreadyOpened = false;
if (!FHasAccessPermission(node, FUserId, true))
{
return(Catalog.GetString("Sorry, you don't have enough permissions to do this"));
}
string strNamespace = TYml2Xml.GetAttributeRecursive(node, "Namespace");
if (strNamespace.Length == 0)
{
return("There is no namespace for " + node.Name);
}
if (!FGUIAssemblies.Keys.Contains(strNamespace))
{
// work around dlls containing several namespaces, eg Ict.Petra.Client.MFinance.Gui contains AR as well
string DllName = TAppSettingsManager.ApplicationDirectory + Path.DirectorySeparatorChar + strNamespace;
if (!System.IO.File.Exists(DllName + ".dll"))
{
DllName = DllName.Substring(0, DllName.LastIndexOf("."));
}
try
{
FGUIAssemblies.Add(strNamespace, Assembly.LoadFrom(DllName + ".dll"));
}
catch (Exception exp)
{
return("error loading assembly " + strNamespace + ".dll: " + exp.Message);
}
}
Assembly asm = FGUIAssemblies[strNamespace];
string actionClick = TYml2Xml.GetAttribute(node, "ActionClick");
string actionOpenScreen = TYml2Xml.GetAttribute(node, "ActionOpenScreen");
if (actionClick.Contains("."))
{
string className = actionClick.Substring(0, actionClick.IndexOf("."));
string methodName = actionClick.Substring(actionClick.IndexOf(".") + 1);
System.Type classType = asm.GetType(strNamespace + "." + className);
if (classType == null)
{
return("cannot find class " + strNamespace + "." + className + " for " + node.Name);
}
MethodInfo method = classType.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public);
if (method != null)
{
List <object> parameters = new List <object>();
parameters.Add(AParentWindow);
// Check the parameters, if we have such an attribute
foreach (ParameterInfo param in method.GetParameters())
{
// ignore the first letter, A, eg. in ALedgerNumber
if (TYml2Xml.HasAttributeRecursive(node, param.Name.Substring(1)))
{
Object obj = TYml2Xml.GetAttributeRecursive(node, param.Name.Substring(1));
if (param.ParameterType == typeof(Int32))
{
obj = Convert.ToInt32(obj);
}
else if (param.ParameterType == typeof(Int64))
{
obj = Convert.ToInt64(obj);
}
else if (param.ParameterType == typeof(bool))
{
obj = Convert.ToBoolean(obj);
}
else if (param.ParameterType == typeof(string))
{
// leave it as string
}
else if (param.ParameterType.IsEnum)
{
obj = Enum.Parse(param.ParameterType, obj.ToString(), true);
}
else
{
// to avoid that Icon is set etc, clear obj
obj = null;
}
if (obj != null)
{
parameters.Add(obj);
}
}
}
if (SomeParentDependsOnLedger(node))
{
parameters.Add((object)FCurrentLedger);
}
method.Invoke(null, parameters.ToArray());
}
else
{
return("cannot find method " + className + "." + methodName + " for " + node.Name);
}
}
else if (actionOpenScreen.Length > 0)
{
string className = actionOpenScreen;
System.Object screen = null;
System.Type classType = asm.GetType(strNamespace + "." + className);
if (classType == null)
{
return("cannot find class " + strNamespace + "." + className + " for " + node.Name);
}
// TODO: check if user has permissions for this screen?
// needs to be implemented as a static function of the screen, GetRequiredPermission returns the permission that is needed (eg PTNRUSER)
// also use something similar as in lstFolderNavigation: CheckAccessPermissionDelegate?
// delegate as a static function that is available from everywhere?
try
{
if (OpenNewOrExistingForm != null)
{
screen = OpenNewOrExistingForm(classType, AParentWindow, out FormWasAlreadyOpened, false);
}
else
{
screen = Activator.CreateInstance(classType, new object[] { AParentWindow });
}
}
catch (System.Reflection.TargetInvocationException E)
{
TLogging.Log(E.ToString());
String msg = E.Message;
if (E.InnerException != null)
{
msg = E.InnerException.Message;
}
return(msg);
}
if (!FormWasAlreadyOpened)
{
// check for properties and according attributes; this works for the LedgerNumber at the moment
foreach (PropertyInfo prop in classType.GetProperties())
{
if (TYml2Xml.HasAttributeRecursive(node, prop.Name))
{
Object obj = TYml2Xml.GetAttributeRecursive(node, prop.Name);
if (prop.PropertyType == typeof(Int32))
{
obj = Convert.ToInt32(obj);
}
else if (prop.PropertyType == typeof(Int64))
{
obj = Convert.ToInt64(obj);
}
else if (prop.PropertyType == typeof(bool))
{
obj = Convert.ToBoolean(obj);
}
else if (prop.PropertyType == typeof(string))
{
// leave it as string
}
else if (prop.PropertyType.IsEnum)
{
obj = Enum.Parse(prop.PropertyType, obj.ToString(), true);
}
else
{
// to avoid that Icon is set etc, clear obj
obj = null;
}
if (obj != null)
{
prop.SetValue(screen, obj, null);
}
}
if (prop.Name == "LedgerNumber")
{
if (SomeParentDependsOnLedger(node))
{
prop.SetValue(screen, (object)FCurrentLedger, null);
}
}
}
MethodInfo method = classType.GetMethod("Show", BindingFlags.Public | BindingFlags.Instance, null, CallingConventions.Any,
new Type[] { }, null);
if (method != null)
{
method.Invoke(screen, null);
FLastOpenedScreen = (Form)screen;
}
else
{
return("cannot find method " + className + ".Show for " + node.Name);
}
}
}
else if (actionClick.Length == 0)
{
return("No action defined for " + node.Name);
}
else
{
return("Invalid action " + actionClick + " defined for " + node.Name);
}
return("");
}
/// <summary>
/// add a folder to the list
/// </summary>
public void AddFolder(XmlNode AFolderNode, string AUserId, CheckAccessPermissionDelegate AHasAccessPermission)
{
TRbtNavigationButton rbt = new TRbtNavigationButton(FolderCheckChanging);
this.sptNavigation.Panel2.Controls.Add(rbt);
rbt.Dock = System.Windows.Forms.DockStyle.Bottom;
rbt.Tag = AFolderNode;
rbt.Name = "rbt" + AFolderNode.Name;
rbt.Text = GetLabel(AFolderNode);
// TODO: pick up icon from within the resx file, if it is available?
if (TYml2Xml.HasAttribute(AFolderNode,
"Icon") &&
System.IO.File.Exists(ResourceDirectory + System.IO.Path.DirectorySeparatorChar +
TYml2Xml.GetAttribute(AFolderNode, "Icon")))
{
rbt.Icon = ResourceDirectory + System.IO.Path.DirectorySeparatorChar + TYml2Xml.GetAttribute(AFolderNode, "Icon");
}
rbt.CheckedChanged += new System.EventHandler(this.FolderCheckedChanged);
if ((TYml2Xml.HasAttribute(AFolderNode, "Enabled")) &&
(TYml2Xml.GetAttribute(AFolderNode, "Enabled").ToLower() == "false"))
{
rbt.Enabled = false;
}
else
{
rbt.Enabled = AHasAccessPermission(AFolderNode, AUserId, false);
}
}
/// <summary>write the code for the designer file where the properties of the control are written</summary>
public override ProcessTemplate SetControlProperties(TFormWriter writer, TControlDef ctrl)
{
base.SetControlProperties(writer, ctrl);
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "DefaultValue"))
{
writer.SetControlProperty(ctrl,
"Text",
"\"" + TYml2Xml.GetAttribute(ctrl.xmlNode, "DefaultValue") + "\"");
}
if ((TYml2Xml.HasAttribute(ctrl.xmlNode, "Multiline")) && (TYml2Xml.GetAttribute(ctrl.xmlNode, "Multiline") == "true"))
{
writer.SetControlProperty(ctrl, "Multiline", "true");
if ((TYml2Xml.HasAttribute(ctrl.xmlNode, "WordWrap")) && (TYml2Xml.GetAttribute(ctrl.xmlNode, "WordWrap") == "false"))
{
writer.SetControlProperty(ctrl, "WordWrap", "false");
}
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "ScrollBars"))
{
writer.SetControlProperty(ctrl, "ScrollBars", "ScrollBars." + TYml2Xml.GetAttribute(ctrl.xmlNode, "ScrollBars"));
}
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "MinimumSize"))
{
writer.SetControlProperty(ctrl, "MinimumSize", "new System.Drawing.Size(" + TYml2Xml.GetAttribute(ctrl.xmlNode,
"MinimumSize") + ")");
}
}
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "TextAlign"))
{
writer.SetControlProperty(ctrl, "TextAlign", "HorizontalAlignment." + TYml2Xml.GetAttribute(ctrl.xmlNode, "TextAlign"));
}
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "CharacterCasing"))
{
writer.SetControlProperty(ctrl, "CharacterCasing", "CharacterCasing." +
TYml2Xml.GetAttribute(ctrl.xmlNode, "CharacterCasing"));
}
if ((TYml2Xml.HasAttribute(ctrl.xmlNode, "PasswordEntry")) && (TYml2Xml.GetAttribute(ctrl.xmlNode, "PasswordEntry") == "true"))
{
writer.SetControlProperty(ctrl, "UseSystemPasswordChar", "true");
}
writer.Template.AddToCodelet("ASSIGNFONTATTRIBUTES",
"this." + ctrl.controlName + ".Font = TAppSettingsManager.GetDefaultBoldFont();" + Environment.NewLine);
return(writer.FTemplate);
}
/// <summary>
/// this function should be used for any collection of controls: on a TabPage, in a table, in a groupbox, radio button list etc.
/// </summary>
/// <returns>the layout control that still needs to be added to the parent</returns>
public void CreateLayout(TFormWriter writer, TControlDef parentContainer, TControlDef layoutPanel, Int32 ANewWidth, Int32 ANewHeight)
{
if (layoutPanel == null)
{
layoutPanel = parentContainer;
}
// first check if the table layout has already been defined in the container with sets of rows?
XmlNode containerNode = parentContainer.xmlNode;
XmlNode controlsNode = TXMLParser.GetChild(containerNode, "Controls");
if (controlsNode != null)
{
FTabOrder = TYml2Xml.GetAttribute(controlsNode, "TabOrder");
}
List <XmlNode> childNodes = TYml2Xml.GetChildren(controlsNode, true);
if ((childNodes.Count > 0) && TYml2Xml.GetElementName(childNodes[0]).StartsWith("Row"))
{
// create a layout using the defined rows in Controls
// create TableLayoutPanel that has as many columns (including the labels) and rows as needed
FOrientation = eOrientation.TableLayout;
FCurrentRow = 0;
FCurrentColumn = 0;
FColumnCount = 2;
// determine maximum number of columns
foreach (XmlNode row in TYml2Xml.GetChildren(controlsNode, true))
{
// one other column for the label; will be cleaned up in WriteTableLayout
int columnCount = 2 * TYml2Xml.GetElements(row).Count;
if (columnCount > FColumnCount)
{
FColumnCount = columnCount;
}
}
FRowCount = TYml2Xml.GetChildren(controlsNode, true).Count;
InitTableLayoutGrid();
foreach (TControlDef childctrl in parentContainer.Children)
{
childctrl.parentName = layoutPanel.controlName;
}
}
else
{
// create TableLayoutPanel that has a column for the labels and as many rows as needed
FCurrentRow = 0;
FCurrentColumn = 0;
if (FOrientation == eOrientation.Vertical)
{
FColumnCount = 2;
FRowCount = parentContainer.Children.Count;
}
else if (FOrientation == eOrientation.Horizontal)
{
// horizontal: label and control, all controls in one row
FColumnCount = parentContainer.Children.Count * 2;
FRowCount = 1;
}
InitTableLayoutGrid();
foreach (TControlDef childControl in parentContainer.Children)
{
childControl.parentName = layoutPanel.controlName;
}
}
#region Custom Column Widths and custom Row Heights
/*
* Record custom Column Widths, if specified.
*/
XmlNode colWidthsNode = TXMLParser.GetChild(containerNode, "ColWidths");
StringCollection ColWidths = TYml2Xml.GetElements(colWidthsNode);
if (ColWidths.Count > 0)
{
FColWidths = new Dictionary <int, string>();
foreach (string colWidth in ColWidths)
{
// Console.WriteLine(containerNode.Name + ".colWidth: " + colWidth + " " + String.Format("FColWidths: {0} / {1})",
// colWidth.Substring(0, colWidth.IndexOf('=')),
// colWidth.Substring(colWidth.IndexOf('=') + 1)));
FColWidths.Add(Convert.ToInt32(colWidth.Substring(0, colWidth.IndexOf('='))),
colWidth.Substring(colWidth.IndexOf('=') + 1));
}
}
/*
* Record custom Row Heights, if specified.
*/
XmlNode colHeightsNode = TXMLParser.GetChild(containerNode, "RowHeights");
StringCollection RowHeights = TYml2Xml.GetElements(colHeightsNode);
if (RowHeights.Count > 0)
{
FRowHeights = new Dictionary <int, string>();
foreach (string rowHeight in RowHeights)
{
// Console.WriteLine(containerNode.Name + ".rowHeight: " + rowHeight + " " + String.Format("FRowHeights: {0} / {1})",
// rowHeight.Substring(0, rowHeight.IndexOf('=')),
// rowHeight.Substring(rowHeight.IndexOf('=') + 1)));
FRowHeights.Add(Convert.ToInt32(rowHeight.Substring(0, rowHeight.IndexOf('='))),
rowHeight.Substring(rowHeight.IndexOf('=') + 1));
}
}
#endregion
}
/// <summary>
/// get the radio buttons
/// </summary>
public override void ProcessChildren(TFormWriter writer, TControlDef ctrl)
{
StringCollection optionalValues =
TYml2Xml.GetElements(TXMLParser.GetChild(ctrl.xmlNode, "OptionalValues"));
string DefaultValue;
if ((TYml2Xml.HasAttribute(ctrl.xmlNode, "NoDefaultValue") &&
((TYml2Xml.GetAttribute(ctrl.xmlNode, "NoDefaultValue")) == "true")))
{
DefaultValue = String.Empty;
FNoDefaultValue = true;
}
else
{
DefaultValue = optionalValues[0];
}
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "DefaultValue"))
{
DefaultValue = TYml2Xml.GetAttribute(ctrl.xmlNode, "DefaultValue");
}
else
{
// DefaultValue with = sign before control name
for (int counter = 0; counter < optionalValues.Count; counter++)
{
if (optionalValues[counter].StartsWith("="))
{
optionalValues[counter] = optionalValues[counter].Substring(1).Trim();
DefaultValue = optionalValues[counter];
}
}
}
StringCollection optionalValuesLabels =
TYml2Xml.GetElements(TYml2Xml.GetChild(ctrl.xmlNode, "LabelsForOptionalValues"));
StringCollection optionalValuesConstants =
TYml2Xml.GetElements(TYml2Xml.GetChild(ctrl.xmlNode, "OptionalValuesConstants"));
// add the radiobuttons on the fly
int count = 0;
foreach (string optionalValue in optionalValues)
{
string radioButtonName = "rbt" +
StringHelper.UpperCamelCase(optionalValue.Replace("'", "").Replace(" ",
"_").Replace("&",
""), false, false);
TControlDef newCtrl = writer.CodeStorage.FindOrCreateControl(radioButtonName, ctrl.controlName);
newCtrl.Label = optionalValuesLabels.Count > 0 ? optionalValuesLabels[count] : optionalValue;
if (StringHelper.IsSame(DefaultValue, optionalValue))
{
newCtrl.SetAttribute("RadioChecked", "true");
FDefaultValueRadioButton = radioButtonName;
}
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "SuppressChangeDetection"))
{
newCtrl.SetAttribute("SuppressChangeDetection", TYml2Xml.GetAttribute(ctrl.xmlNode, "SuppressChangeDetection"));
}
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "OnChange"))
{
newCtrl.SetAttribute("OnChange", TYml2Xml.GetAttribute(ctrl.xmlNode, "OnChange"));
}
if (optionalValuesConstants.Count > count)
{
newCtrl.SetAttribute("ConstantValue", optionalValuesConstants[count]);
}
ctrl.Children.Add(newCtrl);
count++;
}
base.ProcessChildren(writer, ctrl);
}
/// <summary>write the code for the designer file where the properties of the control are written</summary>
public override ProcessTemplate SetControlProperties(TFormWriter writer, TControlDef ctrl)
{
if (!ctrl.HasAttribute("Width"))
{
ctrl.SetAttribute("Width", FDefaultWidth.ToString());
}
base.SetControlProperties(writer, ctrl);
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".CancelEditingWithEscapeKey = false;" + Environment.NewLine);
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "SelectedRowActivates"))
{
// TODO: this function needs to be called by the manual code at the moment when eg a search finishes
// TODO: call "Activate" + TYml2Xml.GetAttribute(ctrl.xmlNode, "SelectedRowActivates")
}
StringCollection Columns = TYml2Xml.GetElements(ctrl.xmlNode, "Columns");
if (Columns.Count > 0)
{
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".Columns.Clear();" + Environment.NewLine);
//This needs to come immediately after the Columns.Clear() and before the creation of the columns
if (ctrl.HasAttribute("SortableHeaders"))
{
string trueOrFalse = ctrl.GetAttribute("SortableHeaders");
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".SortableHeaders = " + trueOrFalse + ";" + Environment.NewLine);
}
foreach (string ColumnFieldName in Columns)
{
bool IsDetailNotMaster;
TTableField field = null;
string TableFieldTable;
string ColumnFieldNameResolved;
// customfield, eg. UC_GLTransactions, ATransaction.DateEntered and ATransaction.AnalysisAttributes
// there needs to be a list of CustomColumns
XmlNode CustomColumnsNode = TYml2Xml.GetChild(ctrl.xmlNode, "CustomColumns");
XmlNode CustomColumnNode = null;
if (CustomColumnsNode != null)
{
CustomColumnNode = TYml2Xml.GetChild(CustomColumnsNode, ColumnFieldName);
}
if ((ctrl.controlName == "grdDetails") && FCodeStorage.HasAttribute("DetailTable"))
{
TableFieldTable = FCodeStorage.GetAttribute("DetailTable");
if (ColumnFieldName.StartsWith("Detail") && !IsLegitimateDetailFieldName(TableFieldTable, ColumnFieldName))
{
ColumnFieldNameResolved = ColumnFieldName.Substring(6); // Drop 'Details' out of 'Details...'
}
else
{
ColumnFieldNameResolved = ColumnFieldName;
}
}
else
{
TableFieldTable = ctrl.GetAttribute("TableName");
ColumnFieldNameResolved = ColumnFieldName;
}
if (CustomColumnNode != null)
{
// if grd has no TableName property
if ((TableFieldTable == "") && ColumnFieldNameResolved.Contains("."))
{
int Period = ColumnFieldNameResolved.IndexOf(".");
string TableName = ColumnFieldNameResolved.Remove(Period);
string ColumnName = ColumnFieldNameResolved.Remove(0, TableName.Length + 1);
AddColumnToGrid(writer, ctrl.controlName,
TYml2Xml.GetAttribute(CustomColumnNode, "Type"),
TYml2Xml.GetAttribute(CustomColumnNode, "Label"),
TYml2Xml.GetAttribute(CustomColumnNode, "Tooltip"),
TableName,
ColumnName);
}
else
{
AddColumnToGrid(writer, ctrl.controlName,
TYml2Xml.GetAttribute(CustomColumnNode, "Type"),
TYml2Xml.GetAttribute(CustomColumnNode, "Label"),
TYml2Xml.GetAttribute(CustomColumnNode, "Tooltip"),
TableFieldTable,
ColumnFieldNameResolved);
}
}
else if (ctrl.HasAttribute("TableName"))
{
field =
TDataBinding.GetTableField(null, ctrl.GetAttribute("TableName") + "." + ColumnFieldName, out IsDetailNotMaster,
true);
}
else
{
field = TDataBinding.GetTableField(null, ColumnFieldName, out IsDetailNotMaster, true);
}
if (field != null)
{
AddColumnToGrid(writer, ctrl.controlName,
field.iDecimals == 10 && field.iLength == 24 ? "Decimal" : field.GetDotNetType(),
field.strLabel.Length > 0 ? field.strLabel : field.strName,
String.Empty,
TTable.NiceTableName(field.strTableName),
TTable.NiceFieldName(field.strName));
}
}
}
else
{
//If no columns, but the user is able to add columns dynamically during the running of the form, then need this here.
if (ctrl.HasAttribute("SortableHeaders"))
{
string trueOrFalse = ctrl.GetAttribute("SortableHeaders");
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".SortableHeaders = " + trueOrFalse + ";" + Environment.NewLine);
}
}
if (ctrl.controlName != "grdDetails")
{
if (ctrl.HasAttribute("ActionLeavingRow"))
{
AssignEventHandlerToControl(writer, ctrl, "Selection.FocusRowLeaving", "SourceGrid.RowCancelEventHandler",
ctrl.GetAttribute("ActionLeavingRow"));
}
if (ctrl.HasAttribute("ActionFocusRow"))
{
AssignEventHandlerToControl(writer, ctrl, "Selection.FocusRowEntered", "SourceGrid.RowEventHandler",
ctrl.GetAttribute("ActionFocusRow"));
}
}
if (ctrl.HasAttribute("ActionEnterKeyPressed"))
{
AssignEventHandlerToControl(writer, ctrl, "EnterKeyPressed", "TKeyPressedEventHandler",
ctrl.GetAttribute("ActionEnterKeyPressed"));
}
if ((ctrl.controlName == "grdDetails") && FCodeStorage.HasAttribute("DetailTable"))
{
writer.Template.AddToCodelet("SHOWDATA", "");
if (ctrl.HasAttribute("SortOrder"))
{
// SortOrder is comma separated and has DESC or ASC after the column name
string SortOrder = ctrl.GetAttribute("SortOrder");
foreach (string SortOrderPart in SortOrder.Split(','))
{
bool temp;
TTableField field = null;
if ((SortOrderPart.Split(' ')[0].IndexOf(".") == -1) && ctrl.HasAttribute("TableName"))
{
field = TDataBinding.GetTableField(null, ctrl.GetAttribute("TableName") + "." + SortOrderPart.Split(
' ')[0], out temp, true);
}
else
{
field =
TDataBinding.GetTableField(
null,
SortOrderPart.Split(' ')[0],
out temp, true);
}
if (field != null)
{
SortOrder = SortOrder.Replace(SortOrderPart.Split(' ')[0], field.strName);
}
}
writer.Template.AddToCodelet("GRIDSORT", SortOrder);
}
if (ctrl.HasAttribute("RowFilter"))
{
// this references a field in the table, and assumes there exists a local variable with the same name
// eg. FBatchNumber in GL Journals
string RowFilter = ctrl.GetAttribute("RowFilter");
String FilterString = "\"";
foreach (string RowFilterPart in RowFilter.Split(','))
{
bool temp;
string columnName =
TDataBinding.GetTableField(
null,
RowFilterPart,
out temp, true).strName;
if (FilterString.Length > 1)
{
FilterString += " + \" and ";
}
FilterString += columnName + " = \" + F" + TTable.NiceFieldName(columnName) + ".ToString()";
}
writer.Template.AddToCodelet("GRIDFILTER", FilterString);
}
}
if (ctrl.controlName == "grdDetails")
{
if (ctrl.HasAttribute("EnableMultiSelection"))
{
writer.Template.SetCodelet("GRIDMULTISELECTION",
String.Format("grdDetails.Selection.EnableMultiSelection = {0};{1}", ctrl.GetAttribute("EnableMultiSelection"),
Environment.NewLine));
}
else if (FCodeStorage.FControlList.ContainsKey("btnDelete"))
{
writer.Template.SetCodelet("GRIDMULTISELECTION",
"grdDetails.Selection.EnableMultiSelection = true;" + Environment.NewLine);
}
}
return(writer.FTemplate);
}
private static string GetLabelOrName(XmlNode ANode)
{
return(TYml2Xml.HasAttribute(ANode, "Label") ? TYml2Xml.GetAttribute(ANode, "Label") : StringHelper.ReverseUpperCamelCase(ANode.Name));
}
/// <summary>check if the generator fits the given control by checking the prefix and perhaps some of the attributes</summary>
public override bool ControlFitsNode(XmlNode curNode)
{
if (base.ControlFitsNode(curNode))
{
if ((TYml2Xml.GetAttribute(curNode, "Format") != String.Empty))
{
return(false);
}
if (TYml2Xml.GetAttribute(curNode, "Type") == "PartnerKey")
{
FButtonLabelType = "PartnerKey";
if (!(TYml2Xml.HasAttribute(curNode,
"ShowLabel") && (TYml2Xml.GetAttribute(curNode, "ShowLabel").ToLower() == "false")))
{
FDefaultWidth = 370;
}
else
{
FDefaultWidth = 80;
}
FHasReadOnlyProperty = true;
return(true);
}
else if (TYml2Xml.GetAttribute(curNode, "Type") == "Extract")
{
FButtonLabelType = "Extract";
return(true);
}
else if (TYml2Xml.GetAttribute(curNode, "Type") == "Occupation")
{
FButtonLabelType = "OccupationList";
return(true);
}
else if (TYml2Xml.GetAttribute(curNode, "Type") == "Conference")
{
FButtonLabelType = "Conference";
if (!(TYml2Xml.HasAttribute(curNode,
"ShowLabel") && (TYml2Xml.GetAttribute(curNode, "ShowLabel").ToLower() == "false")))
{
FDefaultWidth = 370;
}
else
{
FDefaultWidth = 80;
}
FHasReadOnlyProperty = true;
return(true);
}
else if (TYml2Xml.GetAttribute(curNode, "Type") == "Event")
{
FButtonLabelType = "Event";
if (!(TYml2Xml.HasAttribute(curNode,
"ShowLabel") && (TYml2Xml.GetAttribute(curNode, "ShowLabel").ToLower() == "false")))
{
FDefaultWidth = 370;
}
else
{
FDefaultWidth = 80;
}
FHasReadOnlyProperty = true;
return(true);
}
else if (TYml2Xml.GetAttribute(curNode, "Type") == "Bank")
{
FButtonLabelType = "Bank";
if (!(TYml2Xml.HasAttribute(curNode,
"ShowLabel") && (TYml2Xml.GetAttribute(curNode, "ShowLabel").ToLower() == "false")))
{
FDefaultWidth = 370;
}
else
{
FDefaultWidth = 80;
}
FHasReadOnlyProperty = true;
return(true);
}
}
return(false);
}
/// <summary>
/// add Catalog.GetString for each label and description in the UINavigation file to the dummy file to prepare the translation files
/// </summary>
/// <param name="UINavigationFilename">yml file</param>
/// <param name="ATranslationWriter">dummy cs file that is used to provide the strings to gettext</param>
public static void AddTranslationUINavigation(string UINavigationFilename, StreamWriter ATranslationWriter)
{
TYml2Xml parser = new TYml2Xml(UINavigationFilename);
XmlDocument doc = parser.ParseYML2XML();
XmlNode OpenPetraNode = doc.FirstChild.NextSibling.FirstChild;
XmlNode SearchBoxesNode = OpenPetraNode.FirstChild;
XmlNode MainMenuNode = SearchBoxesNode.NextSibling;
XmlNode DepartmentNode = MainMenuNode.FirstChild;
while (DepartmentNode != null)
{
ATranslationWriter.WriteLine("Catalog.GetString(\"" + GetLabelOrName(DepartmentNode) + "\");");
XmlNode ModuleNode = DepartmentNode.FirstChild;
while (ModuleNode != null)
{
ATranslationWriter.WriteLine("Catalog.GetString(\"" + GetLabelOrName(ModuleNode) + "\");");
XmlNode SubModuleNode = ModuleNode.FirstChild;
while (SubModuleNode != null)
{
ATranslationWriter.WriteLine("Catalog.GetString(\"" + GetLabelOrName(SubModuleNode) + "\");");
XmlNode TaskGroupNode = SubModuleNode.FirstChild;
while (TaskGroupNode != null)
{
ATranslationWriter.WriteLine("Catalog.GetString(\"" + GetLabelOrName(TaskGroupNode) + "\");");
XmlNode TaskNode = TaskGroupNode.FirstChild;
while (TaskNode != null)
{
ATranslationWriter.WriteLine("Catalog.GetString(\"" + GetLabelOrName(TaskNode) + "\");");
if (TYml2Xml.HasAttribute(TaskNode, "Description"))
{
ATranslationWriter.WriteLine("Catalog.GetString(\"" + TYml2Xml.GetAttribute(TaskNode, "Description") + "\");");
}
TaskNode = TaskNode.NextSibling;
}
TaskGroupNode = TaskGroupNode.NextSibling;
}
SubModuleNode = SubModuleNode.NextSibling;
}
ModuleNode = ModuleNode.NextSibling;
}
DepartmentNode = DepartmentNode.NextSibling;
}
}
/// <summary>check if the generator fits the given control by checking the prefix and perhaps some of the attributes</summary>
public override bool ControlFitsNode(XmlNode curNode)
{
bool ReturnValue = false;
string NumberFormat;
string PotentialDecimalPrecision;
string PotentialNullValue;
//Console.WriteLine("TTxtNumericTextBoxGenerator ControlFitsNode");
if (base.ControlFitsNode(curNode))
{
FDefaultWidth = 80;
NumberFormat = TYml2Xml.GetAttribute(curNode, "Format");
//Console.WriteLine("TTxtNumericTextBoxGenerator Format: '" + NumberFormat + "'");
if ((NumberFormat == "Integer") ||
(NumberFormat == "PercentInteger"))
{
FControlMode = "Integer";
ReturnValue = true;
}
if (NumberFormat == "LongInteger")
{
FControlMode = "LongInteger";
ReturnValue = true;
}
if ((NumberFormat == "Decimal") ||
(NumberFormat == "PercentDecimal") ||
(NumberFormat.StartsWith("Decimal(")) ||
(NumberFormat.StartsWith("PercentDecimal(")))
{
FControlMode = "Decimal";
ReturnValue = true;
}
if (ReturnValue)
{
if ((NumberFormat.StartsWith("Decimal(")) ||
(NumberFormat.StartsWith("PercentDecimal(")))
{
PotentialDecimalPrecision = NumberFormat.Substring(NumberFormat.IndexOf('(') + 1,
NumberFormat.IndexOf(')') - NumberFormat.IndexOf('(') - 1);
//Console.WriteLine("TTxtNumericTextBoxGenerator: PotentialDecimalPrecision: " + PotentialDecimalPrecision);
if (PotentialDecimalPrecision != String.Empty)
{
try
{
FDecimalPrecision = Convert.ToInt16(PotentialDecimalPrecision);
}
catch (System.FormatException)
{
throw new ApplicationException(
"TextBox with decimal formatting: The specifier for the decimal precision '" + PotentialDecimalPrecision +
"' is not a number!");
}
catch (Exception)
{
throw;
}
}
}
if (TYml2Xml.HasAttribute(curNode, "NullValueAllowed"))
{
PotentialNullValue = TYml2Xml.GetAttribute(curNode, "NullValueAllowed");
if ((PotentialNullValue == "true") ||
(PotentialNullValue == "false"))
{
FNullValueAllowed = Convert.ToBoolean(PotentialNullValue);
}
else
{
throw new ApplicationException(
"TextBox with number formatting: Value for 'NullValueAllowed' needs to be either 'true' or 'false', but is '" +
PotentialNullValue + "'.");
}
}
}
return(ReturnValue);
}
return(false);
}
/// <summary>
/// this will get the proper label for any navigation node;
/// this is public and static so that the TPnlAccordion can access it too.
/// </summary>
/// <param name="ANode"></param>
/// <returns></returns>
public static string GetLabel(XmlNode ANode)
{
return(Catalog.GetString(TYml2Xml.HasAttribute(ANode, "Label") ? TYml2Xml.GetAttribute(ANode,
"Label") : StringHelper.ReverseUpperCamelCase(ANode.Name)));
}
/// <summary>
/// process the yaml document
/// </summary>
/// <returns></returns>
public Boolean ProcessDocument()
{
string baseyaml;
if (!TYml2Xml.ReadHeader(FYamlFilename, out baseyaml))
{
Console.WriteLine("ProcessYAML: cannot recognise type of form");
}
else
{
new TAppSettingsManager(false);
//******************
//* parsing *******
//******************
XmlDocument myDoc = TYml2Xml.CreateXmlDocument();
TCodeStorage codeStorage = new TCodeStorage(myDoc, FXmlNodes);
TParseYAMLFormsDefinition yamlParser = new TParseYAMLFormsDefinition(ref codeStorage);
// should not need to be specific to special forms
yamlParser.LoadRecursively(FYamlFilename, FSelectedLocalisation);
// for debugging purposes, we can write the xml file that has been parsed from the yaml file
// codeStorage.FXmlDocument.Save(FYamlFilename + ".xml");
//****************
//* output *******
//****************
TFormWriter writer = null;
// get the appropriate derived class from IFormWriter (e.g. TFrmReportWriter)
XmlNode rootNode = (XmlNode)yamlParser.FCodeStorage.FXmlNodes[TParseYAMLFormsDefinition.ROOTNODEYML];
string formType = TYml2Xml.GetAttribute(rootNode, "FormType");
if (formType == "abstract")
{
Console.WriteLine("Ignore yaml file because it has the formtype abstract: " + FYamlFilename);
return(true);
}
// the Template attribute is also quite important, because it determines which code is written
// FormType is mainly important for the difference of the controls of reports and normal screens
writer = GetWriter(formType);
if (writer == null)
{
Console.WriteLine("cannot find writer for {0}", formType);
return(false);
}
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
string template = TYml2Xml.GetAttribute(rootNode, "Template");
if (template.Length > 0)
{
template = templateDir + Path.DirectorySeparatorChar + template + writer.CodeFileExtension;
}
string destinationFile = writer.CalculateDestinationFilename(FYamlFilename);
string manualCodeFile = writer.CalculateManualCodeFilename(FYamlFilename);
// need to know the path to the manual code file in order to call manual functions which would not be called if they do not exist
codeStorage.ManualCodeFilename = manualCodeFile;
writer.CreateCode(codeStorage, FYamlFilename, template);
writer.CreateResourceFile(FYamlFilename, templateDir);
writer.CreateDesignerFile(FYamlFilename, rootNode, templateDir);
return(writer.WriteFile(destinationFile));
}
return(false);
}
/// <summary>
/// Constructor. Generates several Groups of Tasks from an xml document.
/// </summary>
/// <param name="ATaskGroups"></param>
/// <param name="ATaskAppearance" >Initial appearance of the Tasks.</param>
public TLstTasks(XmlNode ATaskGroups, TaskAppearance ATaskAppearance)
{
this.SuspendLayout();
this.Name = "lstTasks" + ATaskGroups.Name;
this.AutoScroll = true;
// this.HorizontalScroll.Enabled = true;
this.Resize += new EventHandler(ListResize);
XmlNode TaskGroupNode = ATaskGroups.FirstChild;
while (TaskGroupNode != null)
{
if (TaskGroupNode.Name == "SearchBoxes")
{
// TODO Search boxes
}
else
{
TUcoTaskGroup TaskGroup = new TUcoTaskGroup();
TaskGroup.GroupTitle = TLstFolderNavigation.GetLabel(TaskGroupNode);
TaskGroup.Name = TaskGroupNode.Name;
TIconCache.TIconSize IconSize = ATaskAppearance ==
TaskAppearance.staLargeTile ? TIconCache.TIconSize.is32by32 : TIconCache.TIconSize.is16by16;
Groups.Add(TaskGroup.Name, TaskGroup);
if (TaskGroupNode.FirstChild == null)
{
// duplicate group node into task; otherwise you would not notice the error in the yml file?
TUcoSingleTask SingleTask = new TUcoSingleTask();
SingleTask.TaskTitle = TLstFolderNavigation.GetLabel(TaskGroupNode);
SingleTask.TaskDescription = TYml2Xml.HasAttribute(TaskGroupNode,
"Description") ? Catalog.GetString(TYml2Xml.GetAttribute(TaskGroupNode, "Description")) : "";
SingleTask.Name = TaskGroupNode.Name;
SingleTask.TaskGroup = TaskGroup;
SingleTask.Tag = TaskGroupNode;
SingleTask.TaskAppearance = ATaskAppearance;
SingleTask.TaskImagePath = DetermineIconForTask(TaskGroupNode);
SingleTask.TaskImage = TIconCache.IconCache.AddOrGetExistingIcon(
SingleTask.TaskImagePath, IconSize);
SingleTask.RequestForDifferentIconSize += new TRequestForDifferentIconSize(SingleTask_RequestForDifferentIconSize);
if (!FHasAccessPermission(TaskGroupNode, FUserId, false))
{
SingleTask.Enabled = false;
}
TaskGroup.Add(SingleTask.Name, SingleTask);
}
else
{
XmlNode TaskNode = TaskGroupNode.FirstChild;
while (TaskNode != null)
{
try
{
// this item should only be displayed if Tax Deductible Percentage is enable
if (TaskNode.Name == "RecipientTaxDeductiblePercentages")
{
if (!FTaxDeductiblePercentageEnabled)
{
continue;
}
}
TUcoSingleTask SingleTask = new TUcoSingleTask();
SingleTask.TaskTitle = TLstFolderNavigation.GetLabel(TaskNode);
SingleTask.TaskDescription = TYml2Xml.HasAttribute(TaskNode,
"Description") ? Catalog.GetString(TYml2Xml.GetAttribute(TaskNode, "Description")) : "";
SingleTask.Name = TaskNode.Name;
SingleTask.TaskGroup = TaskGroup;
SingleTask.Tag = TaskNode;
SingleTask.TaskAppearance = ATaskAppearance;
SingleTask.TaskImagePath = DetermineIconForTask(TaskNode);
SingleTask.TaskImage = TIconCache.IconCache.AddOrGetExistingIcon(
SingleTask.TaskImagePath, IconSize);
SingleTask.RequestForDifferentIconSize += new TRequestForDifferentIconSize(SingleTask_RequestForDifferentIconSize);
if (TTaskList.IsDisabled(TaskNode) || !FHasAccessPermission(TaskNode, FUserId, false))
{
SingleTask.Enabled = false;
}
TaskGroup.Add(SingleTask.Name, SingleTask);
}
finally
{
TaskNode = TaskNode.NextSibling;
}
}
}
// Add TaskGroup to this UserControls' Controls
TaskGroup.Dock = DockStyle.Top;
TaskGroup.Margin = new Padding(3);
TaskGroup.AutoSize = true;
TaskGroup.AutoSizeMode = AutoSizeMode.GrowAndShrink;
TaskGroup.TaskClicked += new EventHandler(SingleTask_ExecuteTask);
TaskGroup.TaskSelected += new EventHandler(SingleTask_TaskSelected);
this.Controls.Add(TaskGroup);
// Make sure Task Groups are shown in correct order and not in reverse order.
// (This is needed because we 'stack them up' with 'TaskGroup.Dock = DockStyle.Top')
TaskGroup.BringToFront();
}
TaskGroupNode = TaskGroupNode.NextSibling;
}
this.ResumeLayout();
}
/// <summary>
/// get the value of the attribute of the root node
/// </summary>
/// <param name="AAttributeName"></param>
/// <returns></returns>
public string GetAttribute(string AAttributeName)
{
return(TYml2Xml.GetAttribute(FRootNode, AAttributeName));
}
/// <summary>write the code for the designer file where the properties of the control are written</summary>
public override ProcessTemplate SetControlProperties(TFormWriter writer, TControlDef ctrl)
{
base.SetControlProperties(writer, ctrl);
if (TYml2Xml.HasAttribute(ctrl.xmlNode, "SelectedRowActivates"))
{
// TODO: this function needs to be called by the manual code at the moment when eg a search finishes
// TODO: call "Activate" + TYml2Xml.GetAttribute(ctrl.xmlNode, "SelectedRowActivates")
}
StringCollection Columns = TYml2Xml.GetElements(ctrl.xmlNode, "Columns");
if (Columns.Count > 0)
{
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".Columns.Clear();" + Environment.NewLine);
foreach (string ColumnFieldName in Columns)
{
bool IsDetailNotMaster;
TTableField field = null;
// customfield, eg. UC_GLTransactions, ATransaction.DateEntered and ATransaction.AnalysisAttributes
// there needs to be a list of CustomColumns
XmlNode CustomColumnsNode = TYml2Xml.GetChild(ctrl.xmlNode, "CustomColumns");
XmlNode CustomColumnNode = null;
if (CustomColumnsNode != null)
{
CustomColumnNode = TYml2Xml.GetChild(CustomColumnsNode, ColumnFieldName);
}
if (CustomColumnNode != null)
{
//string ColumnType = "System.String";
/* TODO DateTime (tracker: #58)
* if (TYml2Xml.GetAttribute(CustomColumnNode, "Type") == "System.DateTime")
* {
* ColumnType = "DateTime";
* }
*/
// TODO: different behaviour for double???
if (TYml2Xml.GetAttribute(CustomColumnNode, "Type") == "Boolean")
{
//ColumnType = "CheckBox";
}
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".Columns.Add(" +
"FMainDS." + ctrl.GetAttribute("TableName") + ".Get" + ColumnFieldName + "DBName(), \"" +
TYml2Xml.GetAttribute(CustomColumnNode, "Label") + "\");" + Environment.NewLine);
}
else if (ctrl.HasAttribute("TableName"))
{
field =
TDataBinding.GetTableField(null, ctrl.GetAttribute("TableName") + "." + ColumnFieldName,
out IsDetailNotMaster,
true);
}
else
{
field = TDataBinding.GetTableField(null, ColumnFieldName, out IsDetailNotMaster, true);
}
if (field != null)
{
//string ColumnType = "System.String";
/* TODO DateTime (tracker: #58)
* if (field.GetDotNetType() == "System.DateTime")
* {
* ColumnType = "DateTime";
* }
*/
// TODO: different behaviour for double???
if (field.GetDotNetType() == "Boolean")
{
//ColumnType = "CheckBox";
}
writer.Template.AddToCodelet("INITMANUALCODE", ctrl.controlName + ".Columns.Add(" +
TTable.NiceTableName(field.strTableName) + "Table.Get" +
TTable.NiceFieldName(field.strName) + "DBName(), \"" +
field.strLabel + "\");" + Environment.NewLine);
}
}
}
if (ctrl.HasAttribute("ActionLeavingRow"))
{
AssignEventHandlerToControl(writer, ctrl, "Selection.FocusRowLeaving", "SourceGrid.RowCancelEventHandler",
ctrl.GetAttribute("ActionLeavingRow"));
}
if (ctrl.HasAttribute("ActionFocusRow"))
{
// TODO AssignEventHandlerToControl(writer, ctrl, "Selection.FocusRowEntered", "SourceGrid.RowEventHandler",
// ctrl.GetAttribute("ActionFocusRow"));
}
if ((ctrl.controlName == "grdDetails") && FCodeStorage.HasAttribute("DetailTable"))
{
writer.Template.AddToCodelet("SHOWDATA", "");
if (ctrl.HasAttribute("SortOrder"))
{
// SortOrder is comma separated and has DESC or ASC after the column name
string SortOrder = ctrl.GetAttribute("SortOrder");
foreach (string SortOrderPart in SortOrder.Split(','))
{
bool temp;
TTableField field = null;
if ((SortOrderPart.Split(' ')[0].IndexOf(".") == -1) && ctrl.HasAttribute("TableName"))
{
field =
TDataBinding.GetTableField(null, ctrl.GetAttribute("TableName") + "." + SortOrderPart.Split(
' ')[0], out temp, true);
}
else
{
field =
TDataBinding.GetTableField(
null,
SortOrderPart.Split(' ')[0],
out temp, true);
}
if (field != null)
{
SortOrder = SortOrder.Replace(SortOrderPart.Split(' ')[0], field.strName);
}
}
writer.Template.AddToCodelet("GRIDSORT", SortOrder);
}
if (ctrl.HasAttribute("RowFilter"))
{
// this references a field in the table, and assumes there exists a local variable with the same name
// eg. FBatchNumber in GL Journals
string RowFilter = ctrl.GetAttribute("RowFilter");
String FilterString = "\"";
foreach (string RowFilterPart in RowFilter.Split(','))
{
bool temp;
string columnName =
TDataBinding.GetTableField(
null,
RowFilterPart,
out temp, true).strName;
if (FilterString.Length > 1)
{
FilterString += " + \" and ";
}
FilterString += columnName + " = \" + F" + TTable.NiceFieldName(columnName) + ".ToString()";
}
writer.Template.AddToCodelet("GRIDFILTER", FilterString);
}
}
return(writer.FTemplate);
}
private static void ParsePartners(ref PartnerImportExportTDS AMainDS,
XmlNode ACurNode,
TDBTransaction ATransaction,
ref TVerificationResultCollection AVerificationResult)
{
XmlNode LocalNode = ACurNode;
while (LocalNode != null)
{
if (LocalNode.Name.StartsWith("PartnerGroup"))
{
ParsePartners(ref AMainDS, LocalNode.FirstChild, ATransaction, ref AVerificationResult);
}
else if (LocalNode.Name.StartsWith("Partner"))
{
PPartnerRow PartnerRow = AMainDS.PPartner.NewRowTyped();
Boolean IsExistingPartner = false;
if (!TYml2Xml.HasAttributeRecursive(LocalNode, "SiteKey"))
{
throw new Exception(Catalog.GetString("Missing SiteKey Attribute"));
}
if (!TYml2Xml.HasAttributeRecursive(LocalNode, "status"))
{
throw new Exception(Catalog.GetString("Missing status Attribute"));
}
// get a new partner key
if (TYml2Xml.HasAttribute(LocalNode, "PartnerKey"))
{
PartnerRow.PartnerKey = Convert.ToInt64(TYml2Xml.GetAttribute(LocalNode, "PartnerKey"));
if (PPartnerAccess.Exists(PartnerRow.PartnerKey, ATransaction))
{
AMainDS.Merge(PPartnerAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, ATransaction));
AMainDS.PPartner.DefaultView.RowFilter = String.Format("{0} = '{1}'",
PPartnerTable.GetPartnerKeyDBName(),
PartnerRow.PartnerKey);
PartnerRow = (PPartnerRow)AMainDS.PPartner.DefaultView[0].Row;
IsExistingPartner = true;
}
else
{
AMainDS.PPartner.Rows.Add(PartnerRow);
}
}
else
{
PartnerRow.PartnerKey = TImportExportYml.NewPartnerKey;
TImportExportYml.NewPartnerKey--;
}
String PartnerClass = TYml2Xml.GetAttributeRecursive(LocalNode, "class");
TLogging.LogAtLevel(TLogging.DEBUGLEVEL_TRACE,
PartnerClass + " " +
LocalNode.Name + " " +
"PartnerKey=" + PartnerRow.PartnerKey
);
if (IsExistingPartner && (PartnerClass != PartnerRow.PartnerClass))
{
throw new Exception(String.Format("Error: Yml contains Existing Partner {0} with a different partner class {1}!",
PartnerRow.PartnerKey, PartnerClass));
}
PartnerRow.PartnerClass = PartnerClass;
if (PartnerClass == MPartnerConstants.PARTNERCLASS_FAMILY)
{
PFamilyRow FamilyRow;
if (IsExistingPartner)
{
AMainDS.Merge(PFamilyAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, ATransaction));
AMainDS.PFamily.DefaultView.RowFilter = String.Format("{0} = '{1}'",
PFamilyTable.GetPartnerKeyDBName(),
PartnerRow.PartnerKey);
FamilyRow = (PFamilyRow)AMainDS.PFamily.DefaultView[0].Row;
}
else
{
FamilyRow = AMainDS.PFamily.NewRowTyped();
FamilyRow.PartnerKey = PartnerRow.PartnerKey;
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_FAMILY;
AMainDS.PFamily.Rows.Add(FamilyRow);
}
FamilyRow.FamilyName = TYml2Xml.GetAttributeRecursive(LocalNode, "LastName");
FamilyRow.FirstName = TYml2Xml.GetAttribute(LocalNode, "FirstName");
FamilyRow.Title = TYml2Xml.GetAttribute(LocalNode, "Title");
if (TYml2Xml.HasAttribute(LocalNode, "CreatedAt"))
{
FamilyRow.DateCreated = Convert.ToDateTime(TYml2Xml.GetAttribute(LocalNode, "CreatedAt"));
}
PartnerRow.AddresseeTypeCode = MPartnerConstants.PARTNERCLASS_FAMILY;
PartnerRow.PartnerShortName =
Calculations.DeterminePartnerShortName(FamilyRow.FamilyName, FamilyRow.Title, FamilyRow.FirstName);
}
if (PartnerClass == MPartnerConstants.PARTNERCLASS_PERSON)
{
PPersonRow PersonRow;
if (IsExistingPartner)
{
AMainDS.Merge(PPersonAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, ATransaction));
AMainDS.PPerson.DefaultView.RowFilter = String.Format("{0} = '{1}'",
PPersonTable.GetPartnerKeyDBName(),
PartnerRow.PartnerKey);
PersonRow = (PPersonRow)AMainDS.PPerson.DefaultView[0].Row;
}
else
{
PersonRow = AMainDS.PPerson.NewRowTyped();
PersonRow.PartnerKey = PartnerRow.PartnerKey;
AMainDS.PPerson.Rows.Add(PersonRow);
}
PersonRow.FamilyName = TYml2Xml.GetAttributeRecursive(LocalNode, "LastName");
PersonRow.FirstName = TYml2Xml.GetAttribute(LocalNode, "FirstName");
PersonRow.Title = TYml2Xml.GetAttribute(LocalNode, "Title");
if (TYml2Xml.HasAttribute(LocalNode, "CreatedAt"))
{
PersonRow.DateCreated = Convert.ToDateTime(TYml2Xml.GetAttribute(LocalNode, "CreatedAt"));
}
// PersonRow.Sp
PartnerRow.PartnerShortName =
Calculations.DeterminePartnerShortName(PersonRow.FamilyName, PersonRow.Title, PersonRow.FirstName);
}
else if (PartnerClass == MPartnerConstants.PARTNERCLASS_ORGANISATION)
{
POrganisationRow OrganisationRow;
if (IsExistingPartner)
{
AMainDS.Merge(POrganisationAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, ATransaction));
AMainDS.POrganisation.DefaultView.RowFilter = String.Format("{0} = '{1}'",
POrganisationTable.GetPartnerKeyDBName(),
PartnerRow.PartnerKey);
OrganisationRow = (POrganisationRow)AMainDS.POrganisation.DefaultView[0].Row;
}
else
{
OrganisationRow = AMainDS.POrganisation.NewRowTyped();
OrganisationRow.PartnerKey = PartnerRow.PartnerKey;
AMainDS.POrganisation.Rows.Add(OrganisationRow);
}
OrganisationRow.OrganisationName = TYml2Xml.GetAttributeRecursive(LocalNode, "Name");
PartnerRow.PartnerShortName = OrganisationRow.OrganisationName;
}
else if (PartnerClass == MPartnerConstants.PARTNERCLASS_UNIT)
{
PUnitRow UnitRow;
if (IsExistingPartner)
{
AMainDS.Merge(PUnitAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, ATransaction));
AMainDS.PUnit.DefaultView.RowFilter = String.Format("{0} = '{1}'",
PUnitTable.GetPartnerKeyDBName(),
PartnerRow.PartnerKey);
UnitRow = (PUnitRow)AMainDS.PUnit.DefaultView[0].Row;
}
else
{
UnitRow = AMainDS.PUnit.NewRowTyped();
UnitRow.PartnerKey = PartnerRow.PartnerKey;
AMainDS.PUnit.Rows.Add(UnitRow);
}
UnitRow.UnitTypeCode = TYml2Xml.GetAttributeRecursive(LocalNode, "UnitTypeCode");
UnitRow.UnitName = TYml2Xml.GetAttributeRecursive(LocalNode, "Name");
if (PartnerRow.PartnerKey < -1)
{
throw new Exception("Invalid Partner Key or No Partner Key - and no proper handling implemented");
// from here...
/*
* AVerificationResult.Add(new TVerificationResult(
* String.Format(Catalog.GetString("Importing Unit {0}"), UnitRow.UnitName),
* Catalog.GetString("You need to provide a partner key for the unit"),
* TResultSeverity.Resv_Critical));
*/
// ...to here: throws Exception in case of a illegal import file?
// The above code must have a glitch
}
if (!TYml2Xml.HasAttribute(LocalNode, "ParentUnitKey"))
{
throw new Exception(
"The currently being processed unit (PartnerKey " +
PartnerRow.PartnerKey +
") requires a ParentUnitKey.");
}
Int64 ParentKey = Convert.ToInt64(TYml2Xml.GetAttributeRecursive(LocalNode, "ParentUnitKey"));
UmUnitStructureRow UnitStructureRow = null;
if (IsExistingPartner)
{
AMainDS.Merge(UmUnitStructureAccess.LoadViaPUnitChildUnitKey(PartnerRow.PartnerKey, ATransaction));
AMainDS.UmUnitStructure.DefaultView.RowFilter = String.Format("{0} = '{1}'",
UmUnitStructureTable.GetChildUnitKeyDBName(),
PartnerRow.PartnerKey);
if (AMainDS.UmUnitStructure.DefaultView.Count > 0)
{
UnitStructureRow = (UmUnitStructureRow)AMainDS.UmUnitStructure.DefaultView[0].Row;
}
}
if (UnitStructureRow == null)
{
UnitStructureRow = AMainDS.UmUnitStructure.NewRowTyped();
UnitStructureRow.ParentUnitKey = ParentKey;
UnitStructureRow.ChildUnitKey = PartnerRow.PartnerKey;
AMainDS.UmUnitStructure.Rows.Add(UnitStructureRow);
}
else
{
UnitStructureRow.ParentUnitKey = ParentKey;
UnitStructureRow.ChildUnitKey = PartnerRow.PartnerKey;
}
PartnerRow.PartnerShortName = UnitRow.UnitName;
}
else if (PartnerClass == MPartnerConstants.PARTNERCLASS_BANK)
{
PBankRow BankRow;
if (IsExistingPartner)
{
AMainDS.Merge(PBankAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, ATransaction));
AMainDS.PBank.DefaultView.RowFilter = String.Format("{0} = '{1}'",
PBankTable.GetPartnerKeyDBName(),
PartnerRow.PartnerKey);
BankRow = (PBankRow)AMainDS.PBank.DefaultView[0].Row;
}
else
{
BankRow = AMainDS.PBank.NewRowTyped();
BankRow.PartnerKey = PartnerRow.PartnerKey;
AMainDS.PBank.Rows.Add(BankRow);
}
BankRow.BranchName = TYml2Xml.GetAttribute(LocalNode, "BranchName");
BankRow.BranchCode = TYml2Xml.GetAttribute(LocalNode, "BranchCode");
BankRow.Bic = TYml2Xml.GetAttribute(LocalNode, "BranchBic");
BankRow.EpFormatFile = TYml2Xml.GetAttribute(LocalNode, "EpFormatFile");
if (TYml2Xml.HasAttribute(LocalNode, "CreatedAt"))
{
BankRow.DateCreated = Convert.ToDateTime(TYml2Xml.GetAttribute(LocalNode, "CreatedAt"));
}
}
else
{
/*
* throw new Exception(
* "Unknown Partner Class" +
* TYml2Xml.GetAttributeRecursive(LocalNode, "class"));
*/
// TODO AVerificationResult add failing problem: unknown partner class
}
PartnerRow.StatusCode = TYml2Xml.GetAttributeRecursive(LocalNode, "status");
// import special types
StringCollection SpecialTypes = StringHelper.StrSplit(TYml2Xml.GetAttributeRecursive(LocalNode, "SpecialTypes"), ",");
if (IsExistingPartner)
{
PPartnerTypeAccess.LoadViaPPartner(AMainDS, PartnerRow.PartnerKey, ATransaction);
}
foreach (string SpecialType in SpecialTypes)
{
PPartnerTypeRow PartnerTypeRow = null;
AMainDS.PPartnerType.DefaultView.RowFilter = String.Format("{0}={1} AND {2}='{3}'",
PPartnerTypeTable.GetPartnerKeyDBName(),
PartnerRow.PartnerKey,
PPartnerTypeTable.GetTypeCodeDBName(),
SpecialType
);
if (AMainDS.PPartnerType.DefaultView.Count > 0)
{
PartnerTypeRow = (PPartnerTypeRow)AMainDS.PPartnerType.DefaultView[0].Row;
}
else
{
PartnerTypeRow = AMainDS.PPartnerType.NewRowTyped();
PartnerTypeRow.PartnerKey = PartnerRow.PartnerKey;
PartnerTypeRow.TypeCode = SpecialType.Trim();
AMainDS.PPartnerType.Rows.Add(PartnerTypeRow);
}
// Check Partner type exists, or create it
bool TypeIsKnown = PTypeAccess.Exists(PartnerTypeRow.TypeCode, ATransaction);
if (!TypeIsKnown)
{
Int32 RowIdx = AMainDS.PType.DefaultView.Find(PartnerTypeRow.TypeCode); // I might have created it a second ago..
if (RowIdx < 0)
{
PTypeRow TypeRow = AMainDS.PType.NewRowTyped();
TypeRow.TypeCode = PartnerTypeRow.TypeCode;
TypeRow.TypeDescription = "Created from YAML import";
AMainDS.PType.Rows.Add(TypeRow);
}
}
}
// import subscriptions
StringCollection Subscriptions = StringHelper.StrSplit(TYml2Xml.GetAttributeRecursive(LocalNode, "Subscriptions"), ",");
foreach (string publicationCode in Subscriptions)
{
PSubscriptionRow subscription = AMainDS.PSubscription.NewRowTyped();
subscription.PartnerKey = PartnerRow.PartnerKey;
subscription.PublicationCode = publicationCode.Trim();
subscription.ReasonSubsGivenCode = "FREE";
AMainDS.PSubscription.Rows.Add(subscription);
}
// import address
XmlNode addressNode = TYml2Xml.GetChild(LocalNode, "Address");
if ((addressNode == null) || (TYml2Xml.GetAttributeRecursive(addressNode, "Street").Length == 0))
{
if (!IsExistingPartner)
{
// add the empty location
PPartnerLocationRow partnerlocation = AMainDS.PPartnerLocation.NewRowTyped(true);
partnerlocation.SiteKey = 0;
partnerlocation.PartnerKey = PartnerRow.PartnerKey;
partnerlocation.DateEffective = DateTime.Now;
partnerlocation.LocationType = "HOME";
partnerlocation.SendMail = false;
partnerlocation.EmailAddress = TYml2Xml.GetAttributeRecursive(addressNode, "Email");
partnerlocation.TelephoneNumber = TYml2Xml.GetAttributeRecursive(addressNode, "Phone");
partnerlocation.MobileNumber = TYml2Xml.GetAttributeRecursive(addressNode, "MobilePhone");
AMainDS.PPartnerLocation.Rows.Add(partnerlocation);
}
}
else
{
PLocationRow location = AMainDS.PLocation.NewRowTyped(true);
location.LocationKey = (AMainDS.PLocation.Rows.Count + 1) * -1;
location.SiteKey = 0;
if (!TYml2Xml.HasAttributeRecursive(LocalNode, "Country"))
{
throw new Exception(Catalog.GetString("Missing Country Attribute"));
}
location.CountryCode = TYml2Xml.GetAttributeRecursive(addressNode, "Country");
location.StreetName = TYml2Xml.GetAttributeRecursive(addressNode, "Street");
location.City = TYml2Xml.GetAttributeRecursive(addressNode, "City");
location.PostalCode = TYml2Xml.GetAttributeRecursive(addressNode, "PostCode");
AMainDS.PLocation.Rows.Add(location);
PPartnerLocationRow partnerlocation = AMainDS.PPartnerLocation.NewRowTyped(true);
partnerlocation.SiteKey = 0;
partnerlocation.LocationKey = location.LocationKey;
partnerlocation.PartnerKey = PartnerRow.PartnerKey;
partnerlocation.SendMail = true;
partnerlocation.DateEffective = DateTime.Now;
partnerlocation.LocationType = "HOME";
partnerlocation.EmailAddress = TYml2Xml.GetAttributeRecursive(addressNode, "Email");
partnerlocation.TelephoneNumber = TYml2Xml.GetAttributeRecursive(addressNode, "Phone");
partnerlocation.MobileNumber = TYml2Xml.GetAttributeRecursive(addressNode, "MobilePhone");
AMainDS.PPartnerLocation.Rows.Add(partnerlocation);
}
// import finance details (bank account number)
XmlNode financialDetailsNode = TYml2Xml.GetChild(LocalNode, "FinancialDetails");
ParseFinancialDetails(AMainDS, financialDetailsNode, PartnerRow.PartnerKey, ATransaction);
}
LocalNode = LocalNode.NextSibling;
}
}
