/// <summary>
/// write an ordered list of tables, ordered by foreign key dependancies
/// </summary>
/// <param name="AStore"></param>
/// <param name="AFilename"></param>
public static void WriteTableList(TDataDefinitionStore AStore, string AFilename)
{
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
ProcessTemplate Template = new ProcessTemplate(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"TableList.cs");
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(templateDir));
List <TTable>tables = AStore.GetTables();
tables = TTableSort.TopologicalSort(AStore, tables);
string namesCodelet = string.Empty;
foreach (TTable t in tables)
{
namesCodelet += "list.Add(\"" + t.strName + "\");" + Environment.NewLine;
}
Template.AddToCodelet("DBTableNames", namesCodelet);
List <TSequence>Sequences = AStore.GetSequences();
namesCodelet = string.Empty;
foreach (TSequence s in Sequences)
{
namesCodelet += "list.Add(\"" + s.strName + "\");" + Environment.NewLine;
}
Template.AddToCodelet("DBSequenceNames", namesCodelet);
Template.FinishWriting(AFilename, ".cs", true);
}
/// <summary>
/// insert a method call
/// </summary>
private static void InsertMethodCall(ProcessTemplate snippet, TypeDeclaration connectorClass, MethodDeclaration m,
ref List <string>AMethodNames)
{
string ParameterDefinition = string.Empty;
string ActualParameters = string.Empty;
AutoGenerationTools.FormatParameters(m.Parameters, out ActualParameters, out ParameterDefinition);
// for standalone: add actual parameters directly
snippet.AddToCodelet("ACTUALPARAMETERS", ActualParameters);
string returntype = AutoGenerationTools.TypeToString(m.TypeReference, "");
if (!returntype.Contains("<"))
{
returntype = returntype == "string" || returntype == "String" ? "System.String" : returntype;
returntype = returntype == "bool" || returntype == "Boolean" ? "System.Boolean" : returntype;
if (returntype.Contains("UINT") || returntype.Contains("unsigned"))
{
returntype = returntype.Contains("UInt32") || returntype == "unsigned int" ? "System.UInt32" : returntype;
returntype = returntype.Contains("UInt16") || returntype == "unsigned short" ? "System.UInt16" : returntype;
returntype = returntype.Contains("UInt64") || returntype == "unsigned long" ? "System.UInt64" : returntype;
}
else
{
returntype = returntype.Contains("Int32") || returntype == "int" ? "System.Int32" : returntype;
returntype = returntype.Contains("Int16") || returntype == "short" ? "System.Int16" : returntype;
returntype = returntype.Contains("Int64") || returntype == "long" ? "System.Int64" : returntype;
}
returntype = returntype.Contains("Decimal") || returntype == "decimal" ? "System.Decimal" : returntype;
}
snippet.SetCodelet("RETURN", returntype != "void" ? "return " : string.Empty);
// avoid duplicate names for webservice methods
string methodname = m.Name;
int methodcounter = 1;
while (AMethodNames.Contains(methodname))
{
methodcounter++;
methodname = m.Name + methodcounter.ToString();
}
AMethodNames.Add(methodname);
snippet.SetCodelet("UNIQUEMETHODNAME", methodname);
snippet.SetCodelet("METHODNAME", m.Name);
snippet.SetCodelet("PARAMETERDEFINITION", ParameterDefinition);
snippet.SetCodelet("RETURNTYPE", returntype);
snippet.SetCodelet("WEBCONNECTORCLASS", connectorClass.Name);
snippet.SetCodelet("ASSIGNRESULTANDRETURN", string.Empty);
snippet.SetCodelet("ADDACTUALPARAMETERS", string.Empty);
int ResultCounter = 0;
if (CheckServerAdminToken(m))
{
snippet.AddToCodelet("ADDACTUALPARAMETERS",
"ActualParameters.Add(\"AServerAdminSecurityToken\", THttpConnector.ServerAdminSecurityToken" +
");" + Environment.NewLine);
}
foreach (ParameterDeclarationExpression p in m.Parameters)
{
if (((ParameterModifiers.Ref & p.ParamModifier) > 0) || ((ParameterModifiers.Out & p.ParamModifier) > 0))
{
// need to assign the result to the ref and the out parameter
snippet.AddToCodelet("ASSIGNRESULTANDRETURN",
p.ParameterName + " = (" + p.TypeReference.ToString() + ") Result[" + ResultCounter.ToString() + "];" +
Environment.NewLine);
ResultCounter++;
}
if ((ParameterModifiers.Out & p.ParamModifier) == 0)
{
snippet.AddToCodelet("ADDACTUALPARAMETERS",
"ActualParameters.Add(\"" + p.ParameterName + "\", " +
p.ParameterName + ");" + Environment.NewLine);
}
}
string expectedreturntype = GetExpectedReturnType(ResultCounter, returntype);
snippet.SetCodelet("EXPECTEDRETURNTYPE", expectedreturntype);
snippet.SetCodelet("RESULT", string.Empty);
if ((returntype != "void") || (ResultCounter > 0))
{
snippet.SetCodelet("RESULT", "List<object> Result = ");
}
if (returntype != "void")
{
snippet.AddToCodelet("ASSIGNRESULTANDRETURN",
"return (" + returntype + ") Result[" + ResultCounter.ToString() + "];" + Environment.NewLine);
}
}
/// <summary>
/// insert a method call
/// </summary>
private static void InsertWebConnectorMethodCall(ProcessTemplate snippet,
TypeDeclaration connectorClass,
MethodDeclaration m,
ref List <string>AMethodNames)
{
PrepareParametersForMethod(snippet, m.TypeReference, m.Parameters, m.Name, ref AMethodNames);
snippet.SetCodelet("METHODNAME", m.Name);
snippet.SetCodelet("WEBCONNECTORCLASS", connectorClass.Name);
snippet.InsertSnippet("CHECKUSERMODULEPERMISSIONS",
CreateModuleAccessPermissionCheck(
snippet,
connectorClass.Name,
m));
}
private void CreateAutoHierarchy(TNamespace tn, String AOutputPath)
{
String OutputFile = AOutputPath + Path.DirectorySeparatorChar + "M" + tn.Name +
Path.DirectorySeparatorChar + "Instantiator.AutoHierarchy-generated.cs";
if (Directory.Exists(AOutputPath + Path.DirectorySeparatorChar + "M" + tn.Name +
Path.DirectorySeparatorChar + "connect"))
{
OutputFile = AOutputPath + Path.DirectorySeparatorChar + "M" + tn.Name +
Path.DirectorySeparatorChar + "connect" +
Path.DirectorySeparatorChar + "Instantiator.AutoHierarchy-generated.cs";
}
Console.WriteLine("working on " + OutputFile);
SortedList <string, TypeDeclaration>connectors = TCollectConnectorInterfaces.GetConnectors(tn.Name);
ProcessTemplate Template = new ProcessTemplate(FTemplateDir + Path.DirectorySeparatorChar +
"ClientServerGlue" + Path.DirectorySeparatorChar +
"Instantiator.cs");
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(FTemplateDir));
Template.SetCodelet("TOPLEVELMODULE", tn.Name);
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Petra.Shared.Interfaces.M" + tn.Name + ";" + Environment.NewLine);
string InterfacePath = Path.GetFullPath(AOutputPath).Replace(Path.DirectorySeparatorChar, '/');
InterfacePath = InterfacePath.Substring(0, InterfacePath.IndexOf("csharp/ICT/Petra")) + "csharp/ICT/Petra/Shared/lib/Interfaces";
Template.AddToCodelet("USINGNAMESPACES", CreateInterfaces.AddNamespacesFromYmlFile(InterfacePath, tn.Name));
ProcessTemplate topLevelNamespaceSnippet = Template.GetSnippet("TOPLEVELNAMESPACE");
topLevelNamespaceSnippet.SetCodelet("SUBNAMESPACEREMOTABLECLASSES", "");
topLevelNamespaceSnippet.SetCodelet("TOPLEVELMODULE", tn.Name);
topLevelNamespaceSnippet.InsertSnippet("LOADERCLASS", WriteLoaderClass(Template, tn.Name));
topLevelNamespaceSnippet.InsertSnippet("MAINREMOTABLECLASS",
WriteRemotableClass(
topLevelNamespaceSnippet,
"Ict.Petra.Shared.M" + tn.Name,
"TM" + tn.Name,
"M" + tn.Name,
true,
tn.Children,
connectors));
foreach (TNamespace sn in tn.Children.Values)
{
topLevelNamespaceSnippet.InsertSnippet("SUBNAMESPACEREMOTABLECLASSES",
WriteRemotableClass(
topLevelNamespaceSnippet,
"Ict.Petra.Shared.M" + tn.Name + "." + sn.Name,
sn.Name,
sn.Name,
false,
sn.Children,
connectors));
}
Template.InsertSnippet("CONTENT", topLevelNamespaceSnippet);
Template.FinishWriting(OutputFile, ".cs", true);
}
private static void LayoutCellInForm(TControlDef ACtrl,
Int32 AChildrenCount,
ProcessTemplate ACtrlSnippet,
ProcessTemplate ASnippetCellDefinition)
{
if (ACtrl.HasAttribute("labelWidth"))
{
ASnippetCellDefinition.SetCodelet("LABELWIDTH", ACtrl.GetAttribute("labelWidth"));
}
if (ACtrl.HasAttribute("columnWidth"))
{
ASnippetCellDefinition.SetCodelet("COLUMNWIDTH", ACtrl.GetAttribute("columnWidth").Replace(",", "."));
}
else
{
ASnippetCellDefinition.SetCodelet("COLUMNWIDTH", (1.0 / AChildrenCount).ToString().Replace(",", "."));
}
string Anchor = ANCHOR_DEFAULT_COLUMN;
if (AChildrenCount == 1)
{
Anchor = ANCHOR_SINGLE_COLUMN;
}
if (ACtrl.HasAttribute("columnWidth"))
{
Anchor = "94%";
}
if (ACtrl.GetAttribute("hideLabel") == "true")
{
ACtrlSnippet.SetCodelet("HIDELABEL", "true");
Anchor = ANCHOR_HIDDEN_LABEL;
}
ACtrlSnippet.SetCodelet("ANCHOR", Anchor);
}
/// based on the code model, create the code;
/// using the code generators that have been loaded
public override void CreateCode(TCodeStorage ACodeStorage, string AXAMLFilename, string ATemplateFile)
{
ResetAllValues();
FCodeStorage = ACodeStorage;
TControlGenerator.FCodeStorage = ACodeStorage;
FTemplate = new ProcessTemplate(ATemplateFile);
// load default header with license and copyright
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
FTemplate.AddToCodelet("GPLFILEHEADER",
ProcessTemplate.LoadEmptyFileComment(templateDir + Path.DirectorySeparatorChar + ".." +
Path.DirectorySeparatorChar));
// init some template variables that can be empty
FTemplate.AddToCodelet("INITUSERCONTROLS", "");
FTemplate.AddToCodelet("INITMANUALCODE", "");
FTemplate.AddToCodelet("GRIDMULTISELECTION", "");
FTemplate.AddToCodelet("GRIDHEADERTOOLTIP", "");
FTemplate.AddToCodelet("RUNONCEONACTIVATIONMANUAL", "");
FTemplate.AddToCodelet("RUNONCEONPARENTACTIVATIONMANUAL", "");
FTemplate.AddToCodelet("USERCONTROLSRUNONCEONACTIVATION", "");
FTemplate.AddToCodelet("SETINITIALFOCUS", "");
FTemplate.AddToCodelet("EXITMANUALCODE", "");
FTemplate.AddToCodelet("CANCLOSEMANUAL", "");
FTemplate.AddToCodelet("INITNEWROWMANUAL", "");
FTemplate.AddToCodelet("DELETERECORD", "");
FTemplate.AddToCodelet("DELETEREFERENCECOUNT", "");
FTemplate.AddToCodelet("MULTIDELETEREFERENCECOUNT", "");
FTemplate.AddToCodelet("ENABLEDELETEBUTTON", "");
FTemplate.AddToCodelet("CANDELETESELECTION", "");
FTemplate.AddToCodelet("CANDELETEROW", "");
FTemplate.AddToCodelet("SELECTTABMANUAL", "");
FTemplate.AddToCodelet("STOREMANUALCODE", "");
FTemplate.AddToCodelet("FINDANDFILTERHOOKUPEVENTS", "");
FTemplate.AddToCodelet("ACTIONENABLINGDISABLEMISSINGFUNCS", "");
FTemplate.AddToCodelet("PRIMARYKEYCONTROLSREADONLY", "");
FTemplate.AddToCodelet("SHOWDETAILSMANUAL", "");
FTemplate.AddToCodelet("PREPROCESSCMDKEY", "");
FTemplate.AddToCodelet("PROCESSCMDKEY", "");
FTemplate.AddToCodelet("PROCESSCMDKEYCTRLF", "");
FTemplate.AddToCodelet("PROCESSCMDKEYCTRLR", "");
FTemplate.AddToCodelet("PROCESSCMDKEYMANUAL", "");
FTemplate.AddToCodelet("FOCUSFIRSTEDITABLEDETAILSPANELCONTROL", "");
FTemplate.AddToCodelet("CLEARDETAILS", "");
FTemplate.AddToCodelet("CATALOGI18N", "");
FTemplate.AddToCodelet("DYNAMICTABPAGEUSERCONTROLENUM", "");
FTemplate.AddToCodelet("DYNAMICTABPAGEUSERCONTROLINITIALISATION", "");
FTemplate.AddToCodelet("DYNAMICTABPAGEUSERCONTROLLOADING", "");
FTemplate.AddToCodelet("ASSIGNFONTATTRIBUTES", "");
FTemplate.AddToCodelet("CUSTOMDISPOSING", "");
FTemplate.AddToCodelet("DYNAMICTABPAGEUSERCONTROLDECLARATION", "");
FTemplate.AddToCodelet("DYNAMICTABPAGEBASICS", "");
FTemplate.AddToCodelet("IGNOREFIRSTTABPAGESELECTIONCHANGEDEVENT", "");
FTemplate.AddToCodelet("DYNAMICTABPAGEUSERCONTROLSETUPMETHODS", "");
FTemplate.AddToCodelet("ELSESTATEMENT", "");
// FTemplate.AddToCodelet("VALIDATEDETAILS", "");
FTemplate.AddToCodelet("INITACTIONSTATE", "FPetraUtilsObject.InitActionState();" + Environment.NewLine);
CallHandlerIfProvided("void BeforeShowDetailsManual", "SHOWDETAILS", "BeforeShowDetailsManual(ARow);");
CallHandlerIfProvided("InitializeManualCode", "INITMANUALCODE", "InitializeManualCode();");
CallHandlerIfProvided("RunOnceOnActivationManual", "RUNONCEONACTIVATIONMANUAL", "RunOnceOnActivationManual();");
CallHandlerIfProvided("RunOnceOnParentActivationManual", "RUNONCEONPARENTACTIVATIONMANUAL", "RunOnceOnParentActivationManual();");
CallHandlerIfProvided("ExitManualCode", "EXITMANUALCODE", "ExitManualCode();");
CallHandlerIfProvided("CanCloseManual", "CANCLOSEMANUAL", " && CanCloseManual()");
CallHandlerIfProvided("NewRowManual", "INITNEWROWMANUAL", "NewRowManual(ref NewRow);");
CallHandlerIfProvided("StoreManualCode", "STOREMANUALCODE", "SubmissionResult = StoreManualCode(ref SubmitDS, out VerificationResult);");
CallHandlerIfProvided("FindAndFilterHookUpEvents", "FINDANDFILTERHOOKUPEVENTS", "FindAndFilterHookUpEvents();");
CallHandlerIfProvided("PreProcessCommandKey", "PREPROCESSCMDKEY", "PreProcessCommandKey();");
if (FCodeStorage.ManualFileExistsAndContains("SelectTabManual"))
{
FTemplate.AddToCodelet("SELECTTABMANUAL",
"//Call code to execute on selection of new tab" + Environment.NewLine);
}
if (FCodeStorage.ManualFileExistsAndContains("PreDeleteManual"))
{
FTemplate.AddToCodelet("HASPREDELETEMANUAL", "true");
}
if (FCodeStorage.ManualFileExistsAndContains("DeleteRowManual"))
{
FTemplate.AddToCodelet("HASDELETEROWMANUAL", "true");
}
if (FCodeStorage.ManualFileExistsAndContains("PostDeleteManual"))
{
FTemplate.AddToCodelet("HASPOSTDELETEMANUAL", "true");
}
if (FCodeStorage.ManualFileExistsAndContains("GetChangedRecordCountManual"))
{
FTemplate.AddToCodelet("GETCHANGEDRECORDCOUNT", "return GetChangedRecordCountManual(out AMessage);");
}
else
{
FTemplate.AddToCodelet("GETCHANGEDRECORDCOUNT", "return FPetraUtilsObject.GetChangedRecordCount(FMainDS, out AMessage);");
}
if (FTemplate.FSnippets.ContainsKey("PROCESSCMDKEYCTRLL"))
{
if (FCodeStorage.FControlList.ContainsKey("grdDetails") && !FCodeStorage.FControlList["grdDetails"].HasAttribute("IgnoreEditMove]"))
{
ProcessTemplate snipCtrlL = FTemplate.GetSnippet("PROCESSCMDKEYCTRLL");
FTemplate.InsertSnippet("PROCESSCMDKEY", snipCtrlL);
if (FCodeStorage.FControlList.ContainsKey("pnlDetails"))
{
ProcessTemplate snipCtrlE = FTemplate.GetSnippet("PROCESSCMDKEYCTRLE");
FTemplate.InsertSnippet("PROCESSCMDKEY", snipCtrlE);
ProcessTemplate snipSelectRow = FTemplate.GetSnippet("PROCESSCMDKEYSELECTROW");
FTemplate.InsertSnippet("PROCESSCMDKEY", snipSelectRow);
if (FCodeStorage.ManualFileExistsAndContains("void FocusFirstEditableControlManual()"))
{
FTemplate.SetCodelet("FOCUSFIRSTEDITABLEDETAILSPANELCONTROL", "FocusFirstEditableControlManual();" + Environment.NewLine);
}
else
{
ProcessTemplate snipFocusFirstControl = FTemplate.GetSnippet("FOCUSFIRSTDETAILSPANELCONTROL");
FTemplate.InsertSnippet("FOCUSFIRSTEDITABLEDETAILSPANELCONTROL", snipFocusFirstControl);
}
}
}
if (FCodeStorage.ManualFileExistsAndContains("ProcessCmdKeyManual(ref"))
{
ProcessTemplate snipCmdKeyManual = FTemplate.GetSnippet("PROCESSCMDKEYMANUAL");
FTemplate.InsertSnippet("PROCESSCMDKEYMANUAL", snipCmdKeyManual);
}
}
if ((FTemplate.FSnippets.ContainsKey("PROCESSCMDKEYCTRLF")) && (FCodeStorage.FControlList.ContainsKey("pnlFilterAndFind")))
{
ProcessTemplate snipCtrlF = FTemplate.GetSnippet("PROCESSCMDKEYCTRLF");
if (FCodeStorage.FActionList.ContainsKey("actEditFind"))
{
snipCtrlF.SetCodelet("ACTIONCLICK", FCodeStorage.FActionList["actEditFind"].actionClick);
}
else
{
snipCtrlF.SetCodelet("ACTIONCLICK", "MniFilterFind_Click");
}
FTemplate.InsertSnippet("PROCESSCMDKEY", snipCtrlF);
}
if ((FTemplate.FSnippets.ContainsKey("PROCESSCMDKEYCTRLR")) && (FCodeStorage.FControlList.ContainsKey("pnlFilterAndFind")))
{
ProcessTemplate snipCtrlR = FTemplate.GetSnippet("PROCESSCMDKEYCTRLR");
if (FCodeStorage.FActionList.ContainsKey("actEditFilter"))
{
snipCtrlR.SetCodelet("ACTIONCLICK", FCodeStorage.FActionList["actEditFilter"].actionClick);
}
else
{
snipCtrlR.SetCodelet("ACTIONCLICK", "MniFilterFind_Click");
}
FTemplate.InsertSnippet("PROCESSCMDKEY", snipCtrlR);
}
if (FCodeStorage.HasAttribute("DatasetType"))
{
FTemplate.SetCodelet("DATASETTYPE", FCodeStorage.GetAttribute("DatasetType"));
FTemplate.SetCodelet("SHORTDATASETTYPE",
FCodeStorage.GetAttribute("DatasetType").Substring(FCodeStorage.GetAttribute("DatasetType").LastIndexOf(".") + 1));
FTemplate.SetCodelet("MANAGEDDATASETORTYPE", "true");
}
else
{
FTemplate.SetCodelet("DATASETTYPE", String.Empty);
}
// FTemplate.SetCodelet("MANAGEDDATASETORTYPE", "true");
XmlNode UsingNamespacesNode = TYml2Xml.GetChild(FCodeStorage.FRootNode, "UsingNamespaces");
if (UsingNamespacesNode != null)
{
foreach (string s in TYml2Xml.GetElements(FCodeStorage.FRootNode, "UsingNamespaces"))
{
FTemplate.AddToCodelet("USINGNAMESPACES", "using " + s + ";" + Environment.NewLine);
}
}
else
{
FTemplate.AddToCodelet("USINGNAMESPACES", "");
}
SortedList <string, TTable>DataSetTables = null;
// load the dataset if there is a dataset defined for this screen. this allows us to reference customtables and custom fields
if (FCodeStorage.HasAttribute("DatasetType"))
{
DataSetTables = TDataBinding.LoadDatasetTables(CSParser.ICTPath, FCodeStorage.GetAttribute("DatasetType"), FCodeStorage);
}
else
{
TDataBinding.FCodeStorage = FCodeStorage;
TDataBinding.ResetCurrentDataset();
}
if (FCodeStorage.HasAttribute("MasterTable"))
{
if ((DataSetTables != null) && DataSetTables.ContainsKey(FCodeStorage.GetAttribute("MasterTable")))
{
TTable table = DataSetTables[FCodeStorage.GetAttribute("MasterTable")];
FTemplate.AddToCodelet("MASTERTABLE", table.strVariableNameInDataset);
FTemplate.AddToCodelet("MASTERTABLETYPE", table.strDotNetName);
FTemplate.SetCodelet("SHAREDVALIDATIONNAMESPACEMODULE",
String.Format("Ict.Petra.Shared.{0}.Validation",
TTable.GetNamespace(table.strGroup)));
}
else
{
FTemplate.AddToCodelet("MASTERTABLE", FCodeStorage.GetAttribute("MasterTable"));
TTable table = TDataBinding.FPetraXMLStore.GetTable(FCodeStorage.GetAttribute("MasterTable"));
FTemplate.SetCodelet("SHAREDVALIDATIONNAMESPACEMODULE",
String.Format("Ict.Petra.Shared.{0}.Validation",
TTable.GetNamespace(table.strGroup)));
if (FCodeStorage.HasAttribute("MasterTableType"))
{
FTemplate.AddToCodelet("MASTERTABLETYPE", FCodeStorage.GetAttribute("MasterTableType"));
}
else
{
FTemplate.AddToCodelet("MASTERTABLETYPE", FCodeStorage.GetAttribute("MasterTable"));
}
}
}
else
{
FTemplate.AddToCodelet("MASTERTABLE", "");
FTemplate.AddToCodelet("MASTERTABLETYPE", "");
}
if (FCodeStorage.HasAttribute("DetailTable"))
{
string detailTable;
if ((DataSetTables != null) && DataSetTables.ContainsKey(FCodeStorage.GetAttribute("DetailTable")))
{
TTable table = DataSetTables[FCodeStorage.GetAttribute("DetailTable")];
if (table == null)
{
throw new Exception("invalid DetailTable, does not exist: " + FCodeStorage.GetAttribute("DetailTable"));
}
FTemplate.SetCodelet("SHAREDVALIDATIONNAMESPACEMODULE",
String.Format("Ict.Petra.Shared.{0}.Validation",
TTable.GetNamespace(table.strGroup)));
detailTable = table.strVariableNameInDataset;
FTemplate.AddToCodelet("DETAILTABLE", detailTable);
FTemplate.AddToCodelet("DETAILTABLETYPE", table.strDotNetName);
}
else
{
detailTable = FCodeStorage.GetAttribute("DetailTable");
FTemplate.AddToCodelet("DETAILTABLE", detailTable);
FTemplate.AddToCodelet("DETAILTABLETYPE", detailTable);
TTable table = TDataBinding.FPetraXMLStore.GetTable(detailTable);
FTemplate.SetCodelet("SHAREDVALIDATIONNAMESPACEMODULE",
String.Format("Ict.Petra.Shared.{0}.Validation",
TTable.GetNamespace(table.strGroup)));
}
if ((FTemplate.FSnippets.Keys.Contains("INLINETYPEDDATASET"))
&& (!FCodeStorage.HasAttribute("DatasetType")))
{
ProcessTemplate inlineTypedDataSetSnippet = FTemplate.GetSnippet("INLINETYPEDDATASET");
inlineTypedDataSetSnippet.SetCodelet("DETAILTABLE", detailTable);
FTemplate.InsertSnippet("INLINETYPEDDATASET", inlineTypedDataSetSnippet);
}
}
else
{
FTemplate.AddToCodelet("DETAILTABLE", "");
FTemplate.AddToCodelet("DETAILTABLETYPE", "");
}
if (FCodeStorage.HasAttribute("TempTableName"))
{
FTemplate.AddToCodelet("TEMPTABLENAME", FCodeStorage.GetAttribute("TempTableName"));
}
if (FCodeStorage.HasAttribute("CacheableTable"))
{
FTemplate.AddToCodelet("CACHEABLETABLE", "\"" + FCodeStorage.GetAttribute("CacheableTable") + "\"");
if (FCodeStorage.HasAttribute("CacheableTableSpecificFilter"))
{
FTemplate.AddToCodelet("FILTERVAR", "object FFilter;");
string CacheableTableSpecificFilter = FCodeStorage.GetAttribute("CacheableTableSpecificFilter");
if (CacheableTableSpecificFilter.StartsWith("\""))
{
FTemplate.AddToCodelet("LOADDATAONCONSTRUCTORRUN", "LoadDataAndFinishScreenSetup();");
FTemplate.AddToCodelet("CACHEABLETABLERETRIEVEMETHOD", "GetCacheableDataTableFromCache");
FTemplate.AddToCodelet("DISPLAYFILTERINFORMTITLE", "this.Text = this.Text + \" [Filtered]\";");
FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERLOAD", "" + CacheableTableSpecificFilter + ", FFilter");
FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERSAVE", ", " + CacheableTableSpecificFilter + ", FFilter");
}
else
{
FTemplate.AddToCodelet("LOADDATAONCONSTRUCTORRUN",
"// LoadDataAndFinishScreenSetup() needs to be called manually after setting FFilter!");
FTemplate.AddToCodelet("CACHEABLETABLERETRIEVEMETHOD", "GetSpecificallyFilteredCacheableDataTableFromCache");
FTemplate.AddToCodelet("DISPLAYFILTERINFORMTITLE",
"this.Text = this.Text + \" [" + CacheableTableSpecificFilter + " = \" + FFilter.ToString() + \"]\";");
FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERLOAD", "\"" + CacheableTableSpecificFilter + "\", FFilter");
FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERSAVE", ", FFilter");
}
FTemplate.AddToCodelet("CACHEABLETABLESAVEMETHOD", "SaveSpecificallyFilteredCacheableDataTableToPetraServer");
//FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERSAVE", "FFilter, out VerificationResult");
}
else
{
FTemplate.AddToCodelet("FILTERVAR", "");
FTemplate.AddToCodelet("DISPLAYFILTERINFORMTITLE", "");
FTemplate.AddToCodelet("LOADDATAONCONSTRUCTORRUN", "LoadDataAndFinishScreenSetup();");
FTemplate.AddToCodelet("CACHEABLETABLERETRIEVEMETHOD", "GetCacheableDataTableFromCache");
FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERLOAD", "String.Empty, null");
FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERSAVE", "");
FTemplate.AddToCodelet("CACHEABLETABLESAVEMETHOD", "SaveChangedCacheableDataTableToPetraServer");
//FTemplate.AddToCodelet("CACHEABLETABLESPECIFICFILTERSAVE", "out VerificationResult");
}
}
if (FCodeStorage.HasAttribute("GenerateGetSelectedDetailRow")
&& (FCodeStorage.GetAttribute("GenerateGetSelectedDetailRow") == "true"))
{
FTemplate.AddToCodelet("GENERATEGETSELECTEDDETAILROW", "true");
}
if (FCodeStorage.HasAttribute("MultipleMasterRows")
&& (FCodeStorage.GetAttribute("MultipleMasterRows") == "true"))
{
FTemplate.AddToCodelet("MULTIPLEMASTERROWS", "true");
}
// Note - this IF clause needs to be the same as the one in generateReferenceCountConnectors.cs which is generating the server side code
// Do Ctrl+F to find: this IF clause needs to be the same
// in that file
if ((FCodeStorage.GetAttribute("DetailTable") != String.Empty)
&& (FCodeStorage.FControlList.ContainsKey("btnDelete")
|| FCodeStorage.FControlList.ContainsKey("btnDeleteType")
|| FCodeStorage.FControlList.ContainsKey("btnDeleteExtract")
|| FCodeStorage.FControlList.ContainsKey("btnDeleteDetail")
|| (FCodeStorage.FControlList.ContainsKey("btnRemoveDetail") && (FCodeStorage.GetAttribute("FormType") != "report"))))
{
// We always auto-generate code to calculate the record reference count when a delete button exists unless specified in YAML
if (TYml2Xml.GetAttribute((XmlNode)FCodeStorage.FXmlNodes["actDelete"], "SkipReferenceCheck").ToLower() != "true")
{
AddDeleteReferenceCountImplementation();
}
// The generated code only writes the delete button event handler if there is a delete button and there is no manual code to handle the event
if ((FCodeStorage.FActionList.ContainsKey("actDelete") && (FCodeStorage.FActionList["actDelete"].actionClick != "DeleteRecord"))
|| FCodeStorage.ManualFileExistsAndContains("btnDelete.Click +=")
|| FCodeStorage.ManualFileExistsAndContains("void DeleteRecord(")
|| FCodeStorage.ManualFileExistsAndContains("void DeleteDetail(")
|| FCodeStorage.ManualFileExistsAndContains("void DeleteRow(")
|| FCodeStorage.ManualFileExistsAndContains("void RemoveDetail("))
{
// Handled by manual code
Console.WriteLine("Skipping DeleteRecord() handler because it is handled by " +
Path.GetFileNameWithoutExtension(FCodeStorage.FManualCodeFilename));
}
else
{
// Write the event handler to call the DeleteTableName() method
string deleteRecord = String.Format(
"{1}{0}private void DeleteRecord(Object sender, EventArgs e){1}{0}{{{1}{0}{0}Delete{2}();{1}{0}}}{1}{1}",
" ",
Environment.NewLine,
FCodeStorage.GetAttribute("DetailTable"));
FTemplate.AddToCodelet("DELETERECORD", deleteRecord);
ProcessTemplate snippetCanDelete = FTemplate.GetSnippet("SNIPCANDELETESELECTION");
ProcessTemplate snippetCanDeleteRow = FTemplate.GetSnippet("SNIPCANDELETEROW");
bool bRequiresCanDeleteSelection = false;
// Write the one-line codelet that handles enable/disable of the delete button
string enableDelete = "btnDelete.Enabled = pnlDetails.Enabled";
string enableDeleteExtra = " && CanDeleteSelection()";
if (FCodeStorage.FControlList.ContainsKey("chkDetailDeletable")
|| FCodeStorage.FControlList.ContainsKey("chkDeletable"))
{
enableDelete += enableDeleteExtra;
snippetCanDelete.SetCodelet("DELETEABLEFLAG", "Deletable");
snippetCanDeleteRow.SetCodelet("DELETEABLEFLAG", "Deletable");
bRequiresCanDeleteSelection = true;
}
else if (FCodeStorage.FControlList.ContainsKey("chkDetailDeletableFlag")
|| FCodeStorage.FControlList.ContainsKey("chkDeletableFlag"))
{
enableDelete += enableDeleteExtra;
snippetCanDelete.SetCodelet("DELETEABLEFLAG", "DeletableFlag");
snippetCanDeleteRow.SetCodelet("DELETEABLEFLAG", "DeletableFlag");
bRequiresCanDeleteSelection = true;
}
else if (FCodeStorage.FControlList.ContainsKey("chkDetailTypeDeletable"))
{
enableDelete += enableDeleteExtra;
snippetCanDelete.SetCodelet("DELETEABLEFLAG", "TypeDeletable");
snippetCanDeleteRow.SetCodelet("DELETEABLEFLAG", "TypeDeletable");
bRequiresCanDeleteSelection = true;
}
enableDelete += ";" + Environment.NewLine;
FTemplate.AddToCodelet("ENABLEDELETEBUTTON", enableDelete);
if (bRequiresCanDeleteSelection)
{
snippetCanDelete.SetCodelet("DETAILTABLE", FCodeStorage.GetAttribute("DetailTable"));
FTemplate.InsertSnippet("CANDELETESELECTION", snippetCanDelete);
snippetCanDeleteRow.SetCodelet("DETAILTABLE", FCodeStorage.GetAttribute("DetailTable"));
FTemplate.InsertSnippet("CANDELETEROW", snippetCanDeleteRow);
}
}
}
if (FTemplate.FCodelets["CANDELETEROW"].ToString() == String.Empty)
{
FTemplate.SetCodelet("CANDELETEROW", "return true;");
}
// find the first control that is a panel or groupbox or tab control
if (FCodeStorage.HasRootControl("content"))
{
AddRootControl("content");
}
// Toolbar
if (FCodeStorage.HasRootControl("tbr"))
{
AddRootControl("tbr");
}
// Main Menu
if (FCodeStorage.HasRootControl("mnu"))
{
AddRootControl("mnu");
}
// Statusbar
if (FCodeStorage.HasRootControl("stb"))
{
AddRootControl("stb");
}
// check for controls that have no parent
List <TControlDef>orphans = FCodeStorage.GetOrphanedControls();
if (orphans.Count > 0)
{
string msg = String.Empty;
foreach (TControlDef o in orphans)
{
msg += o.controlName + " ";
}
TLogging.Log("Warning !!! There are some controls that will not be part of the screen (missing parent control?): " + msg);
}
// add form events
foreach (TEventHandler handler in FCodeStorage.FEventList.Values)
{
SetEventHandlerForForm(handler);
}
foreach (TReportParameter ReportPara in FCodeStorage.FReportParameterList.Values)
{
AddReportParameterImplementaion(ReportPara);
}
XmlNode rootNode = (XmlNode)FCodeStorage.FXmlNodes[TParseYAMLFormsDefinition.ROOTNODEYML];
if (TYml2Xml.HasAttribute(rootNode, "UIConnectorType") && TYml2Xml.HasAttribute(rootNode, "UIConnectorCreate"))
{
FTemplate.AddToCodelet("UICONNECTORTYPE", TYml2Xml.GetAttribute(rootNode, "UIConnectorType"));
FTemplate.AddToCodelet("UICONNECTORCREATE", TYml2Xml.GetAttribute(rootNode, "UIConnectorCreate"));
}
HandleWebConnectors(TYml2Xml.GetAttribute(rootNode, "Namespace"));
if (TYml2Xml.HasAttribute(rootNode, "Icon"))
{
string iconFileName = TYml2Xml.GetAttribute(rootNode, "Icon");
FTemplate.AddToCodelet("ADDMAINCONTROLS",
"this.Icon = (System.Drawing.Icon)resources.GetObject(\"$this.Icon\");" + Environment.NewLine);
AddImageToResource("$this.Icon", iconFileName, "Icon");
}
if (FCodeStorage.FEventHandler.Contains("KeyEventHandler(this.Form_KeyDown)"))
{
// forms that have a KeyDown handler will need KeyPreview
FTemplate.AddToCodelet("ADDMAINCONTROLS", "this.KeyPreview = true;" + Environment.NewLine);
}
string initialFocusControl = String.Empty;
if (FCodeStorage.FControlList.ContainsKey("grdDetails"))
{
initialFocusControl = "grdDetails";
}
if (TYml2Xml.HasAttribute(rootNode, "InitialFocus"))
{
string tryFocus = TYml2Xml.GetAttribute(rootNode, "InitialFocus");
if (FCodeStorage.FControlList.ContainsKey(tryFocus))
{
initialFocusControl = tryFocus;
}
else
{
TLogging.Log("Warning !!! Cannot set initial focus. The specified control was not found: " + tryFocus);
}
}
if (initialFocusControl != String.Empty)
{
FTemplate.SetCodelet("SETINITIALFOCUS", initialFocusControl + ".Focus();");
}
// add title
if (ProperI18NCatalogGetString(FCodeStorage.FFormTitle))
{
FTemplate.AddToCodelet("CATALOGI18N",
"this.Text = Catalog.GetString(\"" + FCodeStorage.FFormTitle + "\");" + Environment.NewLine);
}
// add actions
foreach (TActionHandler handler in FCodeStorage.FActionList.Values)
{
if (!handler.actionName.StartsWith("cnd"))
{
AddActionHandlerImplementation(handler);
}
if (TYml2Xml.HasAttribute(handler.actionNode, "InitialValue"))
{
string actionEnabling =
"if (e.ActionName == \"" + handler.actionName + "\")" + Environment.NewLine +
"{" + Environment.NewLine +
" {#ENABLEDEPENDINGACTIONS_" + handler.actionName + "}" + Environment.NewLine +
"}" + Environment.NewLine + Environment.NewLine;
Template.AddToCodelet("ACTIONENABLING", actionEnabling);
Template.AddToCodelet(
"INITACTIONSTATE",
"ActionEnabledEvent(null, new ActionEventArgs(" +
"\"" + handler.actionName + "\", " + TYml2Xml.GetAttribute(handler.actionNode,
"InitialValue") + "));" + Environment.NewLine);
}
if (TYml2Xml.HasAttribute(handler.actionNode, "Enabled"))
{
Template.AddToCodelet(
"ENABLEDEPENDINGACTIONS_" + TYml2Xml.GetAttribute(handler.actionNode, "Enabled"),
"FPetraUtilsObject.EnableAction(\"" + handler.actionName + "\", e.Enabled);" + Environment.NewLine);
}
}
WriteAllControls();
FinishUpInitialisingControls();
if (FCodeStorage.ManualFileExistsAndContains("void ShowDataManual()"))
{
FTemplate.AddToCodelet("SHOWDATA", "ShowDataManual();" + Environment.NewLine);
}
else if (FCodeStorage.ManualFileExistsAndContains("void ShowDataManual("))
{
FTemplate.AddToCodelet("SHOWDATA", "ShowDataManual(ARow);" + Environment.NewLine);
}
if (FCodeStorage.FControlList.ContainsKey("pnlDetails"))
{
FTemplate.AddToCodelet("CLEARDETAILS", "FPetraUtilsObject.ClearControls(pnlDetails);" + Environment.NewLine);
}
if (FCodeStorage.ManualFileExistsAndContains("void ShowDetailsManual"))
{
FTemplate.AddToCodelet("SHOWDETAILS", "ShowDetailsManual(ARow);" + Environment.NewLine);
FTemplate.AddToCodelet("CLEARDETAILS", "ShowDetailsManual(ARow);" + Environment.NewLine);
}
if (FCodeStorage.ManualFileExistsAndContains("GetDataFromControlsManual()"))
{
FTemplate.AddToCodelet("SAVEDATA", "GetDataFromControlsManual();" + Environment.NewLine);
}
else if (FCodeStorage.ManualFileExistsAndContains("GetDataFromControlsManual("))
{
FTemplate.AddToCodelet("SAVEDATA", "GetDataFromControlsManual(ARow);" + Environment.NewLine);
}
if (FCodeStorage.ManualFileExistsAndContains("GetDataFromControlsExtra()"))
{
FTemplate.AddToCodelet("SAVEDATAEXTRA", "GetDataFromControlsExtra();" + Environment.NewLine);
}
else if (FCodeStorage.ManualFileExistsAndContains("GetDataFromControlsExtra("))
{
FTemplate.AddToCodelet("SAVEDATAEXTRA", "GetDataFromControlsExtra(ARow);" + Environment.NewLine);
}
else
{
FTemplate.AddToCodelet("SAVEDATAEXTRA", "");
}
// if (FCodeStorage.ManualFileExistsAndContains("ValidateDetailsManual"))
// {
// ProcessTemplate validateSnippet = FTemplate.GetSnippet("VALIDATEDETAILS");
// FTemplate.InsertSnippet("VALIDATEDETAILS", validateSnippet);
// }
//
if (FCodeStorage.ManualFileExistsAndContains("GetDetailDataFromControlsManual"))
{
FTemplate.AddToCodelet("SAVEDETAILS", "GetDetailDataFromControlsManual(ARow);" + Environment.NewLine);
}
if (FCodeStorage.ManualFileExistsAndContains("GetDetailDataFromControlsExtra"))
{
FTemplate.AddToCodelet("SAVEDETAILSEXTRA", "GetDetailDataFromControlsExtra(ARow);" + Environment.NewLine);
}
else
{
FTemplate.AddToCodelet("SAVEDETAILSEXTRA", "");
}
if (FCodeStorage.ManualFileExistsAndContains("void ReadControlsManual"))
{
FTemplate.AddToCodelet("READCONTROLS", "ReadControlsManual(ACalc, AReportAction);" + Environment.NewLine);
}
if (FCodeStorage.ManualFileExistsAndContains("void SetControlsManual"))
{
FTemplate.AddToCodelet("SETCONTROLS", "SetControlsManual(AParameters);" + Environment.NewLine);
}
if (FCodeStorage.ManualFileExistsAndContains("ValidateDataManual"))
{
FTemplate.SetCodelet("VALIDATEDATAMANUAL", "true");
}
if (FCodeStorage.ManualFileExistsAndContains("GetDetailsFromControlsManual"))
{
FTemplate.SetCodelet("GETDETAILSMANUAL", "true");
}
if (FCodeStorage.ManualFileExistsAndContains("ValidateDataDetailsManual"))
{
FTemplate.SetCodelet("VALIDATEDATADETAILSMANUAL", "true");
}
if (FCodeStorage.ManualFileExistsAndContains("GetSelectedDetailRowManual"))
{
FTemplate.AddToCodelet("GETSELECTEDDETAILROW", "return GetSelectedDetailRowManual();" + Environment.NewLine);
}
else
{
string getSelectedDetailRow =
"DataRowView[] SelectedGridRow = grdDetails.SelectedDataRowsAsDataRowView;" + Environment.NewLine + Environment.NewLine +
"if (SelectedGridRow.Length >= 1)" + Environment.NewLine +
"{" + Environment.NewLine +
" return ({#DETAILTABLETYPE}Row)SelectedGridRow[0].Row;" + Environment.NewLine +
"}" + Environment.NewLine + Environment.NewLine +
"return null;" + Environment.NewLine + Environment.NewLine;
FTemplate.SetCodelet("GETSELECTEDDETAILROW", getSelectedDetailRow);
}
InsertCodeIntoTemplate(AXAMLFilename);
}
private static void InsertMainProcedures(TDataDefinitionStore AStore,
TTable ACurrentTable,
ProcessTemplate ATemplate,
ProcessTemplate ASnippet)
{
ASnippet.SetCodelet("TABLENAME", TTable.NiceTableName(ACurrentTable.strName));
ASnippet.SetCodeletComment("TABLE_DESCRIPTION", ACurrentTable.strDescription);
ASnippet.SetCodelet("SQLTABLENAME", ACurrentTable.strName);
ASnippet.SetCodelet("VIAOTHERTABLE", "");
ASnippet.SetCodelet("VIALINKTABLE", "");
string formalParametersPrimaryKey;
string actualParametersPrimaryKey;
string actualParametersPrimaryKeyToString;
int numberPrimaryKeyColumns;
PrepareCodeletsPrimaryKey(ACurrentTable,
out formalParametersPrimaryKey,
out actualParametersPrimaryKey,
out actualParametersPrimaryKeyToString,
out numberPrimaryKeyColumns);
ASnippet.SetCodelet("FORMALPARAMETERSPRIMARYKEY", formalParametersPrimaryKey);
ASnippet.SetCodelet("ACTUALPARAMETERSPRIMARYKEY", actualParametersPrimaryKey);
ASnippet.SetCodelet("ACTUALPARAMETERSPRIMARYKEYTOSTRING", actualParametersPrimaryKeyToString);
ASnippet.SetCodelet("PRIMARYKEYNUMBERCOLUMNS", numberPrimaryKeyColumns.ToString());
string formalParametersUniqueKey;
string actualParametersUniqueKey;
int numberUniqueKeyColumns;
PrepareCodeletsUniqueKey(ACurrentTable,
out formalParametersUniqueKey,
out actualParametersUniqueKey,
out numberUniqueKeyColumns);
ASnippet.SetCodelet("FORMALPARAMETERSUNIQUEKEY", formalParametersUniqueKey);
ASnippet.SetCodelet("ACTUALPARAMETERSUNIQUEKEY", actualParametersUniqueKey);
ASnippet.SetCodelet("UNIQUEKEYNUMBERCOLUMNS", numberUniqueKeyColumns.ToString());
ASnippet.SetCodelet("SEQUENCENAMEANDFIELD", "");
foreach (TTableField tablefield in ACurrentTable.grpTableField)
{
// is there a field filled by a sequence?
// yes: get the next value of that sequence and assign to row
if (tablefield.strSequence.Length > 0)
{
ASnippet.SetCodelet("SEQUENCENAMEANDFIELD", ", \"" + tablefield.strSequence + "\", \"" + tablefield.strName + "\"");
// assume only one sequence per table
break;
}
}
}
/// creates a file with enums in Shared and one file per submodule in Server for cached tables
public static void WriteCachedTables(TDataDefinitionStore AStore,
string ACacheYamlFilename,
string ASharedPath,
string ATemplateDir)
{
// Load yaml file with list of tables that should be cached
TYml2Xml ymlParser = new TYml2Xml(ACacheYamlFilename);
XmlDocument xmlDoc = ymlParser.ParseYML2XML();
XmlNode module = xmlDoc.DocumentElement.FirstChild.FirstChild;
while (module != null)
{
XmlNode subModule = module.FirstChild;
bool severalSubModules = (subModule != null && subModule.NextSibling != null);
// write the shared file with the enum definitions
ProcessTemplate SharedTemplate = new ProcessTemplate(ATemplateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"Cacheable.Shared.cs");
SharedTemplate.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(ATemplateDir));
// SharedTemplate.SetCodelet("NAMESPACE", "Ict.Petra.Shared.M" + module.Name);
SharedTemplate.SetCodelet("NAMESPACE", "Ict.Petra.Shared");
while (subModule != null)
{
List <string>UsingNamespaces = new List <string>();
// write the server file for each submodule
ProcessTemplate ServerTemplate = new ProcessTemplate(ATemplateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"Cacheable.Server.cs");
ServerTemplate.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(ATemplateDir));
ServerTemplate.SetCodelet("NAMESPACE", "Ict.Petra.Server.M" + module.Name + "." + subModule.Name + ".Cacheable");
ServerTemplate.SetCodelet("SUBNAMESPACE", "M" + module.Name + "." + subModule.Name);
ServerTemplate.SetCodelet("CACHEABLECLASS", "T" + module.Name + "Cacheable");
ServerTemplate.SetCodelet("SUBMODULE", subModule.Name);
ServerTemplate.SetCodelet("GETCALCULATEDLISTFROMDB", "");
ServerTemplate.SetCodelet("LEDGERGETCACHEABLE", "");
ServerTemplate.SetCodelet("LEDGERSAVECACHEABLE", "");
if (!severalSubModules)
{
// for MCommon
ServerTemplate.SetCodelet("NAMESPACE", "Ict.Petra.Server.M" + module.Name + ".Cacheable");
ServerTemplate.SetCodelet("SUBNAMESPACE", "M" + module.Name);
ServerTemplate.SetCodelet("CACHEABLECLASS", "TCacheable");
}
ProcessTemplate snippetSubmodule = SharedTemplate.GetSnippet("SUBMODULEENUM");
snippetSubmodule.SetCodelet("SUBMODULE", subModule.Name);
snippetSubmodule.SetCodelet("MODULE", module.Name);
ProcessTemplate snippetLedgerGetTable = null;
ProcessTemplate snippetLedgerSaveTable = null;
XmlNode TableOrListElement = subModule.FirstChild;
while (TableOrListElement != null)
{
XmlNode enumElement = TableOrListElement.FirstChild;
while (enumElement != null)
{
bool DependsOnLedger = false;
if (TYml2Xml.GetAttributeRecursive(enumElement, "DependsOnLedger") == "true")
{
if (snippetLedgerGetTable == null)
{
snippetLedgerGetTable = ServerTemplate.GetSnippet("LEDGERGETCACHEABLE");
snippetLedgerGetTable.SetCodelet("SUBMODULE", subModule.Name);
}
if ((snippetLedgerSaveTable == null) && (TableOrListElement.Name == "DatabaseTables"))
{
snippetLedgerSaveTable = ServerTemplate.GetSnippet("LEDGERSAVECACHEABLE");
snippetLedgerSaveTable.SetCodelet("SUBMODULE", subModule.Name);
}
DependsOnLedger = true;
ServerTemplate.SetCodelet("WITHLEDGER", "true");
}
ProcessTemplate snippetElement = SharedTemplate.GetSnippet("ENUMELEMENT");
if ((enumElement.NextSibling == null)
&& ((TableOrListElement.NextSibling == null) || (TableOrListElement.NextSibling.FirstChild == null)))
{
snippetElement = SharedTemplate.GetSnippet("ENUMELEMENTLAST");
}
string Comment = TXMLParser.GetAttribute(enumElement, "Comment");
if (TableOrListElement.Name == "DatabaseTables")
{
TTable Table = AStore.GetTable(enumElement.Name);
string Namespace = "Ict.Petra.Shared." + TTable.GetNamespace(Table.strGroup) + ".Data";
if (!UsingNamespaces.Contains(Namespace))
{
UsingNamespaces.Add(Namespace);
}
Namespace = "Ict.Petra.Shared." + TTable.GetNamespace(Table.strGroup) + ".Validation";
if (!UsingNamespaces.Contains(Namespace))
{
UsingNamespaces.Add(Namespace);
}
Namespace = "Ict.Petra.Server." + TTable.GetNamespace(Table.strGroup) + ".Data.Access";
if (!UsingNamespaces.Contains(Namespace))
{
UsingNamespaces.Add(Namespace);
}
if (Table == null)
{
throw new Exception("Error: cannot find table " + enumElement.Name + " for caching in module " + module.Name);
}
if (Comment.Length == 0)
{
Comment = Table.strDescription;
}
}
if (Comment.Length == 0)
{
Comment = "todoComment";
}
snippetElement.SetCodelet("ENUMCOMMENT", Comment);
string enumName = enumElement.Name;
if (TXMLParser.HasAttribute(enumElement, "Enum"))
{
enumName = TXMLParser.GetAttribute(enumElement, "Enum");
}
else if (TableOrListElement.Name == "DatabaseTables")
{
string character2 = enumElement.Name.Substring(1, 1);
if (character2.ToLower() == character2)
{
// this is a table name that has a 2 digit prefix
enumName = enumElement.Name.Substring(2) + "List";
}
else
{
enumName = enumElement.Name.Substring(1) + "List";
}
}
snippetElement.SetCodelet("ENUMNAME", enumName);
snippetElement.SetCodelet("DATATABLENAME", enumElement.Name);
snippetSubmodule.InsertSnippet("ENUMELEMENTS", snippetElement);
if (TableOrListElement.Name == "DatabaseTables")
{
ProcessTemplate snippetLoadTable = ServerTemplate.GetSnippet("LOADTABLE");
if (DependsOnLedger)
{
snippetLoadTable = ServerTemplate.GetSnippet("LOADTABLEVIALEDGER");
}
snippetLoadTable.SetCodelet("ENUMNAME", enumName);
snippetLoadTable.SetCodelet("DATATABLENAME", enumElement.Name);
if (DependsOnLedger)
{
snippetLedgerGetTable.InsertSnippet("LOADTABLESANDLISTS", snippetLoadTable);
}
else
{
ServerTemplate.InsertSnippet("LOADTABLESANDLISTS", snippetLoadTable);
}
ProcessTemplate snippetSaveTable = ServerTemplate.GetSnippet("SAVETABLE");
snippetSaveTable.SetCodelet("ENUMNAME", enumName);
snippetSaveTable.SetCodelet("SUBMODULE", subModule.Name);
snippetSaveTable.SetCodelet("DATATABLENAME", enumElement.Name);
if (DependsOnLedger)
{
snippetLedgerSaveTable.InsertSnippet("SAVETABLE", snippetSaveTable);
}
else
{
ServerTemplate.InsertSnippet("SAVETABLE", snippetSaveTable);
}
ProcessTemplate snippetDataValidation = ServerTemplate.GetSnippet("DATAVALIDATION");
snippetDataValidation.SetCodelet("ENUMNAME", enumName);
snippetDataValidation.SetCodelet("DATATABLENAME", enumElement.Name);
if (DependsOnLedger)
{
snippetLedgerSaveTable.InsertSnippet("DATAVALIDATION", snippetDataValidation);
}
else
{
ServerTemplate.InsertSnippet("DATAVALIDATION", snippetDataValidation);
}
}
else
{
ProcessTemplate snippetLoadList = ServerTemplate.GetSnippet("LOADCALCULATEDLIST");
if (DependsOnLedger)
{
snippetLoadList = ServerTemplate.GetSnippet("LOADCALCULATEDLISTFORLEDGER");
}
snippetLoadList.SetCodelet("ENUMNAME", enumName);
snippetLoadList.SetCodelet("CALCULATEDLISTNAME", enumName);
if (DependsOnLedger)
{
snippetLedgerGetTable.InsertSnippet("LOADTABLESANDLISTS", snippetLoadList);
}
else
{
ServerTemplate.InsertSnippet("LOADTABLESANDLISTS", snippetLoadList);
}
if (TYml2Xml.GetAttributeRecursive(enumElement, "IsStorableToDBTable") != String.Empty)
{
ProcessTemplate snippetSaveTable = ServerTemplate.GetSnippet("SAVETABLE");
snippetSaveTable.SetCodelet("ENUMNAME", enumName);
snippetSaveTable.SetCodelet("SUBMODULE", subModule.Name);
snippetSaveTable.SetCodelet("DATATABLENAME", TYml2Xml.GetAttributeRecursive(enumElement, "IsStorableToDBTable"));
if (DependsOnLedger)
{
snippetLedgerSaveTable.InsertSnippet("SAVETABLE", snippetSaveTable);
}
else
{
ServerTemplate.InsertSnippet("SAVETABLE", snippetSaveTable);
}
ProcessTemplate snippetDataValidation = ServerTemplate.GetSnippet("DATAVALIDATION");
snippetDataValidation.SetCodelet("ENUMNAME", enumName);
snippetDataValidation.SetCodelet("DATATABLENAME",
TYml2Xml.GetAttributeRecursive(enumElement, "IsStorableToDBTable"));
if (DependsOnLedger)
{
snippetLedgerSaveTable.InsertSnippet("DATAVALIDATION", snippetDataValidation);
}
else
{
ServerTemplate.InsertSnippet("DATAVALIDATION", snippetDataValidation);
}
}
}
enumElement = enumElement.NextSibling;
if (enumElement != null)
{
snippetSubmodule.AddToCodelet("ENUMELEMENTS", Environment.NewLine);
}
}
TableOrListElement = TableOrListElement.NextSibling;
}
SharedTemplate.InsertSnippet("ENUMS", snippetSubmodule);
if (snippetLedgerGetTable != null)
{
ServerTemplate.InsertSnippet("LEDGERGETCACHEABLE", snippetLedgerGetTable);
}
if (snippetLedgerSaveTable != null)
{
ServerTemplate.InsertSnippet("LEDGERSAVECACHEABLE", snippetLedgerSaveTable);
}
ServerTemplate.SetCodelet("USINGNAMESPACES", string.Empty);
foreach (string UsingNamespace in UsingNamespaces)
{
ServerTemplate.AddToCodelet("USINGNAMESPACES", "using " + UsingNamespace + ";" + Environment.NewLine);
}
string path = ASharedPath +
Path.DirectorySeparatorChar + ".." +
Path.DirectorySeparatorChar + "Server" +
Path.DirectorySeparatorChar + "lib" +
Path.DirectorySeparatorChar + "M" + module.Name +
Path.DirectorySeparatorChar;
if (File.Exists(path + "Cacheable.ManualCode.cs"))
{
path += "Cacheable-generated.cs";
}
else
{
if (File.Exists(path + "data" + Path.DirectorySeparatorChar + subModule.Name + "." + "Cacheable.ManualCode.cs"))
{
path += "data" + Path.DirectorySeparatorChar + subModule.Name + "." + "Cacheable-generated.cs";
}
else if (File.Exists(path + "data" + Path.DirectorySeparatorChar + "Cacheable.ManualCode.cs"))
{
path += "data" + Path.DirectorySeparatorChar + "Cacheable-generated.cs";
}
else
{
path += subModule.Name + "." + "Cacheable-generated.cs";
}
}
ServerTemplate.FinishWriting(path, ".cs", true);
subModule = subModule.NextSibling;
}
SharedTemplate.FinishWriting(ASharedPath +
Path.DirectorySeparatorChar + "M" + module.Name + ".Cacheable-generated.cs",
".cs", true);
module = module.NextSibling;
}
}
public void TestTemplateEngine()
{
ProcessTemplate template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("my test" + Environment.NewLine +
"{#IFDEF TEST1}" + Environment.NewLine +
"test1" + Environment.NewLine +
"{#ENDIF TEST1}" + Environment.NewLine);
template.SetCodelet("TEST1", "test");
Assert.AreEqual("my test" + Environment.NewLine + "test1" + Environment.NewLine,
template.FinishWriting(true),
"TEST1");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("my test" + Environment.NewLine +
"{#IFNDEF TEST2}" + Environment.NewLine +
"test2" + Environment.NewLine +
"{#ENDIFN TEST2}" + Environment.NewLine);
template.SetCodelet("TEST2", "test");
Assert.AreEqual("my test" + Environment.NewLine,
template.FinishWriting(true),
"TEST2");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("my test" + Environment.NewLine +
"{#IFNDEF TEST3}" + Environment.NewLine +
"test3" + Environment.NewLine +
"{#ENDIFN TEST3}" + Environment.NewLine +
"hallo" + Environment.NewLine);
Assert.AreEqual("my test" + Environment.NewLine +
"test3" + Environment.NewLine +
"hallo" + Environment.NewLine,
template.FinishWriting(true),
"TEST3");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("my test" + Environment.NewLine +
"{#IFDEF TEST1}" + Environment.NewLine +
"test1" + Environment.NewLine +
"{#ENDIF TEST1}" + Environment.NewLine +
"{#IFNDEF TEST2}" + Environment.NewLine +
"test2" + Environment.NewLine +
"{#ENDIFN TEST2}" + Environment.NewLine +
"{#IFNDEF TEST3}" + Environment.NewLine +
"test3" + Environment.NewLine +
"{#ENDIFN TEST3}" + Environment.NewLine +
"{#IFDEF TEST4}" + Environment.NewLine +
"test4" + Environment.NewLine +
"{#ENDIF TEST4}" + Environment.NewLine +
"hallo" + Environment.NewLine);
template.SetCodelet("TEST1", "test");
template.SetCodelet("TEST3", "test");
Assert.AreEqual("my test" + Environment.NewLine +
"test1" + Environment.NewLine +
"test2" + Environment.NewLine +
"hallo" + Environment.NewLine,
template.FinishWriting(true),
"TEST4");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("my test" + Environment.NewLine +
"{#IFDEF TEST5 OR TEST1}" + Environment.NewLine +
"test5" + Environment.NewLine +
"{#ENDIF TEST5 OR TEST1}" + Environment.NewLine);
template.SetCodelet("TEST5", "test");
Assert.AreEqual("my test" + Environment.NewLine + "test5" + Environment.NewLine,
template.FinishWriting(true),
"TEST5");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("my test" + Environment.NewLine +
"{#IFDEF TEST5 AND TEST6}" + Environment.NewLine +
"test6" + Environment.NewLine +
"{#ENDIF TEST5 AND TEST6}" + Environment.NewLine);
template.SetCodelet("TEST6", "test");
Assert.AreEqual("my test" + Environment.NewLine,
template.FinishWriting(true),
"TEST6");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("my test" + Environment.NewLine +
"{#IFDEF TEST6 AND TEST7}" + Environment.NewLine +
"test7" + Environment.NewLine +
"{#ENDIF TEST6 AND TEST7}" + Environment.NewLine);
template.SetCodelet("TEST6", "test");
template.SetCodelet("TEST7", "test");
Assert.AreEqual("my test" + Environment.NewLine + "test7" + Environment.NewLine,
template.FinishWriting(true),
"TEST7");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("{#IFDEF TEST8}" + Environment.NewLine +
"test8" + Environment.NewLine +
"{#ENDIF TEST8}" + Environment.NewLine +
"test8" + Environment.NewLine +
"{#IFDEF TEST8}" + Environment.NewLine +
"test8" + Environment.NewLine +
"{#ENDIF TEST8}" + Environment.NewLine);
template.SetCodelet("TEST8", "test");
Assert.AreEqual("test8" + Environment.NewLine + "test8" + Environment.NewLine + "test8" + Environment.NewLine,
template.FinishWriting(true),
"TEST8");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("{#IFNDEF TEST9}" + Environment.NewLine +
"test8" + Environment.NewLine +
"{#ENDIFN TEST9}" + Environment.NewLine +
"test9" + Environment.NewLine +
"{#IFNDEF TEST9}" + Environment.NewLine +
"test8" + Environment.NewLine +
"{#ENDIFN TEST9}" + Environment.NewLine);
template.SetCodelet("TEST9", "test");
Assert.AreEqual("test9" + Environment.NewLine,
template.FinishWriting(true),
"TEST9");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("{#IFNDEF TEST10}" + Environment.NewLine +
"test8" + Environment.NewLine +
"{#ENDIFN TEST10}" + Environment.NewLine +
"test9" + Environment.NewLine +
"{#IFDEF TEST10}" + Environment.NewLine +
"test10" + Environment.NewLine +
"{#ENDIF TEST10}" + Environment.NewLine);
template.SetCodelet("TEST10", "test");
Assert.AreEqual("test9" + Environment.NewLine + "test10" + Environment.NewLine,
template.FinishWriting(true),
"TEST10");
template = new ProcessTemplate();
template.FTemplateCode = new StringBuilder("{#IFDEF TEST10}" + Environment.NewLine +
"{#IFDEF TEST11}" + Environment.NewLine +
"{#IFDEF TEST11}" + Environment.NewLine +
"test11" + Environment.NewLine +
"{#ENDIF TEST11}" + Environment.NewLine +
"{#ENDIF TEST11}" + Environment.NewLine +
"{#IFNDEF TEST11}" + Environment.NewLine +
"test10" + Environment.NewLine +
"{#ENDIFN TEST11}" + Environment.NewLine +
"{#ENDIF TEST10}" + Environment.NewLine +
"{#IFNDEF TEST10}" + Environment.NewLine +
"{#IFNDEF TEST11}" + Environment.NewLine +
"{#IFDEF TEST11}" + Environment.NewLine +
"test13" + Environment.NewLine +
"{#ENDIF TEST11}" + Environment.NewLine +
"{#ENDIFN TEST11}" + Environment.NewLine +
"{#ENDIFN TEST10}" + Environment.NewLine +
"test1" + Environment.NewLine);
template.SetCodelet("TEST11", "test_11");
template.SetCodelet("TEST10", "test_10");
Assert.AreEqual("test11" + Environment.NewLine + "test1" + Environment.NewLine,
template.FinishWriting(true),
"TEST11");
}
/// <summary>
/// main function for generating access methods for typed data sets
/// </summary>
/// <param name="AInputXmlfile"></param>
/// <param name="AOutputPath"></param>
/// <param name="ANameSpace"></param>
/// <param name="store"></param>
/// <param name="groups"></param>
/// <param name="AFilename"></param>
public static void CreateTypedDataSets(String AInputXmlfile,
String AOutputPath,
String ANameSpace,
TDataDefinitionStore store,
string[] groups,
string AFilename)
{
Console.WriteLine("processing dataset " + ANameSpace);
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
ProcessTemplate Template = new ProcessTemplate(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"DataSetAccess.cs");
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(templateDir));
Template.SetCodelet("NAMESPACE", ANameSpace);
// if no dataset is defined yet in the xml file, the following variables can be empty
Template.AddToCodelet("USINGNAMESPACES", "");
Template.AddToCodelet("CONTENTDATASETSANDTABLESANDROWS", "");
Template.AddToCodelet("USINGNAMESPACES", "using " + ANameSpace.Replace(".Server.", ".Shared.") + ";" + Environment.NewLine, false);
TXMLParser parserDataSet = new TXMLParser(AInputXmlfile, false);
XmlDocument myDoc = parserDataSet.GetDocument();
XmlNode startNode = myDoc.DocumentElement;
if (startNode.Name.ToLower() == "petradatasets")
{
XmlNode cur = TXMLParser.NextNotBlank(startNode.FirstChild);
while ((cur != null) && (cur.Name.ToLower() == "importunit"))
{
Template.AddToCodelet("USINGNAMESPACES", "using " + TXMLParser.GetAttribute(cur, "name") + ";" + Environment.NewLine, false);
Template.AddToCodelet("USINGNAMESPACES", "using " + TXMLParser.GetAttribute(cur, "name").Replace(".Shared.",
".Server.") + ".Access;" + Environment.NewLine, false);
cur = TXMLParser.GetNextEntity(cur);
}
while ((cur != null) && (cur.Name.ToLower() == "dataset"))
{
ProcessTemplate snippetDataset = Template.GetSnippet("TYPEDDATASET");
string datasetname = TXMLParser.GetAttribute(cur, "name");
snippetDataset.SetCodelet("DATASETNAME", datasetname);
ProcessTemplate snippetSubmitChanges = snippetDataset.GetSnippet("SUBMITCHANGESFUNCTION");
snippetSubmitChanges.AddToCodelet("DATASETNAME", datasetname);
List <TDataSetTable>tables = new List <TDataSetTable>();
XmlNode curChild = cur.FirstChild;
// first collect the tables
while (curChild != null)
{
if (curChild.Name.ToLower() == "table")
{
string tabletype = TTable.NiceTableName(TXMLParser.GetAttribute(curChild, "sqltable"));
string variablename = (TXMLParser.HasAttribute(curChild, "name") ?
TXMLParser.GetAttribute(curChild, "name") :
tabletype);
TDataSetTable table = new TDataSetTable(
TXMLParser.GetAttribute(curChild, "sqltable"),
tabletype,
variablename,
store.GetTable(tabletype));
tables.Add(table);
}
curChild = curChild.NextSibling;
}
foreach (TDataSetTable table in tables)
{
AddTableToDataset(tables,
store.GetTable(table.tableorig),
table.tablename,
table.tablealias,
snippetDataset,
snippetSubmitChanges);
}
// there is one codelet for the dataset name.
// only add the full submitchanges function if there are any table to submit
if (snippetSubmitChanges.FCodelets.Count > 1)
{
snippetDataset.InsertSnippet("SUBMITCHANGESFUNCTION", snippetSubmitChanges);
}
else
{
snippetDataset.AddToCodelet("SUBMITCHANGESFUNCTION", "");
}
Template.InsertSnippet("CONTENTDATASETSANDTABLESANDROWS", snippetDataset);
cur = TXMLParser.GetNextEntity(cur);
}
}
Template.FinishWriting(AOutputPath + Path.DirectorySeparatorChar + AFilename + "-generated.cs", ".cs", true);
}
/// <summary>
/// generate the connector code for the client
/// </summary>
static public void GenerateConnectorCode(String AOutputPath, String ATemplateDir)
{
String OutputFile = AOutputPath + Path.DirectorySeparatorChar + "ClientGlue.Connector-generated.cs";
Console.WriteLine("working on " + OutputFile);
ProcessTemplate Template = new ProcessTemplate(FTemplateDir + Path.DirectorySeparatorChar +
"ClientServerGlue" + Path.DirectorySeparatorChar +
"ClientGlue.Connector.cs");
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(FTemplateDir));
Template.SetCodelet("USINGNAMESPACES", string.Empty);
if (FCompileForStandalone)
{
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Common.DB;" + Environment.NewLine);
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Common.Remoting.Server;" + Environment.NewLine);
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Petra.Server.App.Core;" + Environment.NewLine);
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Petra.Server.App.Delegates;" + Environment.NewLine);
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Petra.Shared;" + Environment.NewLine);
Template.AddToCodelet("USINGNAMESPACES", "using System.Security.Principal;" + Environment.NewLine);
Template.InsertSnippet("CONNECTOR", Template.GetSnippet("CONNECTORSTANDALONE"));
Template.InsertSnippet("STANDALONECLIENTMANAGER", Template.GetSnippet("STANDALONECLIENTMANAGER"));
}
else
{
Template.InsertSnippet("CONNECTOR", Template.GetSnippet("CONNECTORCLIENTSERVER"));
Template.SetCodelet("STANDALONECLIENTMANAGER", string.Empty);
Template.SetCodelet("HTTPREMOTING", "true");
}
Template.FinishWriting(OutputFile, ".cs", true);
}
static private void CreateClientGlue(TNamespace tn, SortedList <string, TypeDeclaration>connectors, string AOutputPath)
{
String OutputFile = AOutputPath + Path.DirectorySeparatorChar + "ClientGlue.M" + tn.Name +
"-generated.cs";
Console.WriteLine("working on " + OutputFile);
ProcessTemplate Template = new ProcessTemplate(FTemplateDir + Path.DirectorySeparatorChar +
"ClientServerGlue" + Path.DirectorySeparatorChar +
"ClientGlue.cs");
FUsingNamespaces = new SortedList <string, string>();
FModuleHasUIConnector = false;
FUIConnectorsAdded = new List <string>();
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(FTemplateDir));
Template.SetCodelet("TOPLEVELMODULE", tn.Name);
string InterfacePath = Path.GetFullPath(AOutputPath).Replace(Path.DirectorySeparatorChar, '/');
InterfacePath = InterfacePath.Substring(0, InterfacePath.IndexOf("csharp/ICT/Petra")) + "csharp/ICT/Petra/Shared/lib/Interfaces";
Template.AddToCodelet("USINGNAMESPACES", CreateInterfaces.AddNamespacesFromYmlFile(InterfacePath, tn.Name));
if (AOutputPath.Contains("ICT/Petra/Plugins/"))
{
// add namespaces that are required by the plugin
InterfacePath = Path.GetFullPath(AOutputPath + "/../").Replace(Path.DirectorySeparatorChar, '/');
Template.AddToCodelet("USINGNAMESPACES", CreateInterfaces.AddNamespacesFromYmlFile(InterfacePath, "Plugin"));
}
string SharedPathName = "Ict.Petra.Shared.M" + tn.Name;
if (SharedPathName.Contains("ServerAdmin"))
{
SharedPathName = "Ict.Petra.Server.App.Core." + tn.Name;
}
else if (OutputFile.Contains("ICT/Petra/Plugins"))
{
SharedPathName = "Ict.Petra.Plugins." + tn.Name;
}
InsertSubNamespaces(Template, connectors, tn.Name, SharedPathName, tn);
if (FModuleHasUIConnector)
{
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Petra.Shared.Interfaces.M" + tn.Name + ";" + Environment.NewLine);
}
foreach (string usingNamespace in FUsingNamespaces.Keys)
{
Template.AddToCodelet("USINGNAMESPACES", "using " + usingNamespace + ";" + Environment.NewLine);
}
if (OutputFile.Contains("ClientGlue.MServerAdmin"))
{
Template.SetCodelet("REMOTEOBJECTSNAMESPACE", "Ict.Petra.ServerAdmin.App.Core.RemoteObjects");
}
else if (OutputFile.Contains("ICT/Petra/Plugins"))
{
string pluginWithNamespace = TAppSettingsManager.GetValue("plugin");
Template.SetCodelet("REMOTEOBJECTSNAMESPACE", pluginWithNamespace + ".RemoteObjects");
}
else
{
Template.SetCodelet("REMOTEOBJECTSNAMESPACE", "Ict.Petra.Client.App.Core.RemoteObjects");
}
Template.FinishWriting(OutputFile, ".cs", true);
}
static private void InsertSubNamespaces(ProcessTemplate ATemplate,
SortedList <string, TypeDeclaration>connectors,
string AParentNamespaceName,
string AFullNamespace,
TNamespace AParentNamespace)
{
ATemplate.SetCodelet("SUBNAMESPACECLASSES", string.Empty);
ATemplate.SetCodelet("SUBNAMESPACEPROPERTIES", string.Empty);
ATemplate.SetCodelet("CONNECTORMETHODS", string.Empty);
foreach (TNamespace sn in AParentNamespace.Children.Values)
{
ProcessTemplate templateProperty = ATemplate.GetSnippet("SUBNAMESPACEPROPERTY");
templateProperty.SetCodelet("NAMESPACENAME", AParentNamespaceName + sn.Name);
templateProperty.SetCodelet("SUBNAMESPACENAME", sn.Name);
templateProperty.SetCodelet("OBJECTNAME", sn.Name);
ProcessTemplate templateClass = ATemplate.GetSnippet("NAMESPACECLASS");
templateClass.SetCodelet("NAMESPACENAME", AParentNamespaceName + sn.Name);
InsertSubNamespaces(templateClass, connectors,
AParentNamespaceName + sn.Name,
AFullNamespace + "." + sn.Name,
sn);
ATemplate.InsertSnippet("SUBNAMESPACECLASSES", templateClass);
ATemplate.InsertSnippet("SUBNAMESPACEPROPERTIES", templateProperty);
}
if (AParentNamespaceName.EndsWith("WebConnectors"))
{
ImplementWebConnector(connectors, ATemplate, AFullNamespace);
}
else
{
ImplementUIConnector(connectors, ATemplate, AFullNamespace);
}
}
/// <summary>
/// create the code for a typed table
/// </summary>
/// <param name="AStore"></param>
/// <param name="strGroup"></param>
/// <param name="AFilePath"></param>
/// <param name="ANamespaceName"></param>
/// <param name="AFileName"></param>
/// <returns></returns>
public static Boolean WriteTypedTable(TDataDefinitionStore AStore, string strGroup, string AFilePath, string ANamespaceName, string AFileName)
{
Console.WriteLine("processing namespace Typed Tables " + strGroup.Substring(0, 1).ToUpper() + strGroup.Substring(1));
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
ProcessTemplate Template = new ProcessTemplate(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"DataTable.cs");
Template.AddToCodelet("NAMESPACE", ANamespaceName);
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(templateDir));
foreach (TTable currentTable in AStore.GetTables())
{
if (currentTable.strGroup == strGroup)
{
if (!currentTable.HasPrimaryKey())
{
TLogging.Log("Warning: there is no primary key for table " + currentTable.strName);
}
InsertTableDefinition(Template, currentTable, null, "TABLELOOP");
InsertRowDefinition(Template, currentTable, null, "TABLELOOP");
}
}
Template.FinishWriting(AFilePath + AFileName + "-generated.cs", ".cs", true);
return true;
}
/// <summary>
/// code for generating typed datasets
/// </summary>
/// <param name="AInputXmlfile"></param>
/// <param name="AOutputPath"></param>
/// <param name="ANameSpace"></param>
/// <param name="store"></param>
/// <param name="groups"></param>
/// <param name="AFilename"></param>
public static void CreateTypedDataSets(String AInputXmlfile,
String AOutputPath,
String ANameSpace,
TDataDefinitionStore store,
string[] groups,
string AFilename)
{
Console.WriteLine("processing dataset " + ANameSpace);
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
ProcessTemplate Template = new ProcessTemplate(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"DataSet.cs");
Template.AddSnippetsFromOtherFile(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"DataTable.cs");
DataSetTableIdCounter = Convert.ToInt16(TAppSettingsManager.GetValue("StartTableId"));
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(templateDir));
Template.SetCodelet("NAMESPACE", ANameSpace);
// if no dataset is defined yet in the xml file, the following variables can be empty
Template.AddToCodelet("USINGNAMESPACES", "");
Template.AddToCodelet("CONTENTDATASETSANDTABLESANDROWS", "");
TXMLParser parserDataSet = new TXMLParser(AInputXmlfile, false);
XmlDocument myDoc = parserDataSet.GetDocument();
XmlNode startNode = myDoc.DocumentElement;
if (startNode.Name.ToLower() == "petradatasets")
{
XmlNode cur = TXMLParser.NextNotBlank(startNode.FirstChild);
while ((cur != null) && (cur.Name.ToLower() == "importunit"))
{
Template.AddToCodelet("USINGNAMESPACES", "using " + TXMLParser.GetAttribute(cur, "name") + ";" + Environment.NewLine);
cur = TXMLParser.GetNextEntity(cur);
}
while ((cur != null) && (cur.Name.ToLower() == "dataset"))
{
ProcessTemplate snippetDataset = Template.GetSnippet("TYPEDDATASET");
string datasetname = TXMLParser.GetAttribute(cur, "name");
snippetDataset.SetCodelet("DATASETNAME", datasetname);
// INITCONSTRAINTS and INITRELATIONS can be empty
snippetDataset.AddToCodelet("INITCONSTRAINTS", "");
snippetDataset.AddToCodelet("INITRELATIONS", "");
SortedList <string, TDataSetTable>tables = new SortedList <string, TDataSetTable>();
XmlNode curChild = cur.FirstChild;
while (curChild != null)
{
if ((curChild.Name.ToLower() == "table") && TXMLParser.HasAttribute(curChild, "sqltable"))
{
bool OverloadTable = false;
string tabletype = TTable.NiceTableName(TXMLParser.GetAttribute(curChild, "sqltable"));
string variablename = (TXMLParser.HasAttribute(curChild, "name") ?
TXMLParser.GetAttribute(curChild, "name") :
tabletype);
TDataSetTable table = new TDataSetTable(
TXMLParser.GetAttribute(curChild, "sqltable"),
tabletype,
variablename,
store.GetTable(tabletype));
XmlNode tableNodes = curChild.FirstChild;
while (tableNodes != null)
{
if (tableNodes.Name.ToLower() == "customfield")
{
// eg. BestAddress in PartnerEditTDS.PPartnerLocation
TTableField customField = new TTableField();
customField.strName = TXMLParser.GetAttribute(tableNodes, "name");
customField.strTypeDotNet = TXMLParser.GetAttribute(tableNodes, "type");
customField.strDescription = TXMLParser.GetAttribute(tableNodes, "comment");
customField.strDefault = TXMLParser.GetAttribute(tableNodes, "initial");
table.grpTableField.Add(customField);
OverloadTable = true;
}
if (tableNodes.Name.ToLower() == "field")
{
// eg. UnitName in PartnerEditTDS.PPerson
TTableField field = new TTableField(store.GetTable(TXMLParser.GetAttribute(tableNodes, "sqltable")).
GetField(TXMLParser.GetAttribute(tableNodes, "sqlfield")));
if (TXMLParser.HasAttribute(tableNodes, "name"))
{
field.strNameDotNet = TXMLParser.GetAttribute(tableNodes, "name");
}
if (TXMLParser.HasAttribute(tableNodes, "comment"))
{
field.strDescription = TXMLParser.GetAttribute(tableNodes, "comment");
}
table.grpTableField.Add(field);
OverloadTable = true;
}
if (tableNodes.Name.ToLower() == "primarykey")
{
TConstraint primKeyConstraint = table.GetPrimaryKey();
primKeyConstraint.strThisFields = StringHelper.StrSplit(TXMLParser.GetAttribute(tableNodes,
"thisFields"), ",");
OverloadTable = true;
}
tableNodes = tableNodes.NextSibling;
}
if (OverloadTable)
{
tabletype = datasetname + TTable.NiceTableName(table.strName);
if (TXMLParser.HasAttribute(curChild, "name"))
{
tabletype = datasetname + TXMLParser.GetAttribute(curChild, "name");
}
table.strDotNetName = tabletype;
table.strVariableNameInDataset = variablename;
// set tableid
table.iOrder = DataSetTableIdCounter++;
// TODO: can we derive from the base table, and just overload a few functions?
CodeGenerationTable.InsertTableDefinition(snippetDataset, table, store.GetTable(table.tableorig), "TABLELOOP");
CodeGenerationTable.InsertRowDefinition(snippetDataset, table, store.GetTable(table.tableorig), "TABLELOOP");
}
tables.Add(variablename, table);
AddTableToDataset(tabletype, variablename,
snippetDataset);
}
else if ((curChild.Name.ToLower() == "table") && TXMLParser.HasAttribute(curChild, "customtable"))
{
// this refers to a custom table of another dataset, eg. BestAddressTDSLocation
// for the moment, such a table cannot have additional fields
if (curChild.HasChildNodes)
{
throw new Exception(
String.Format(
"CreateTypedDataSets(): At the moment, a custom table referenced from another dataset cannot have additional fields. Dataset: {0}, Table: {1}",
datasetname,
TXMLParser.HasAttribute(curChild, "customtable")));
}
// customtable has to contain the name of the dataset, eg. BestAddressTDSLocation
string tabletype = TXMLParser.GetAttribute(curChild, "customtable");
string variablename = (TXMLParser.HasAttribute(curChild, "name") ?
TXMLParser.GetAttribute(curChild, "name") :
tabletype);
AddTableToDataset(tabletype, variablename,
snippetDataset);
}
if (curChild.Name.ToLower() == "customrelation")
{
ProcessTemplate tempSnippet = Template.GetSnippet("INITRELATIONS");
tempSnippet.SetCodelet("RELATIONNAME", TXMLParser.GetAttribute(curChild, "name"));
tempSnippet.SetCodelet("TABLEVARIABLENAMEPARENT", TXMLParser.GetAttribute(curChild, "parentTable"));
tempSnippet.SetCodelet("TABLEVARIABLENAMECHILD", TXMLParser.GetAttribute(curChild, "childTable"));
tempSnippet.SetCodelet("COLUMNNAMESPARENT",
StringCollectionToValuesFormattedForArray(tables, TXMLParser.GetAttribute(curChild, "parentTable"),
StringHelper.StrSplit(TXMLParser.GetAttribute(curChild, "parentFields"), ",")));
tempSnippet.SetCodelet("COLUMNNAMESCHILD",
StringCollectionToValuesFormattedForArray(tables, TXMLParser.GetAttribute(curChild, "childTable"),
StringHelper.StrSplit(TXMLParser.GetAttribute(curChild, "childFields"), ",")));
tempSnippet.SetCodelet("CREATECONSTRAINTS", TXMLParser.GetBoolAttribute(curChild, "createConstraints") ? "true" : "false");
snippetDataset.InsertSnippet("INITRELATIONS", tempSnippet);
}
if (curChild.Name.ToLower() == "customtable")
{
string variablename = TXMLParser.GetAttribute(curChild, "name");
string tabletype = datasetname + TXMLParser.GetAttribute(curChild, "name");
XmlNode customTableNodes = curChild.FirstChild;
TDataSetTable customTable = new TDataSetTable(
tabletype,
tabletype,
variablename,
null);
// set TableId
customTable.iOrder = DataSetTableIdCounter++;
customTable.strDescription = TXMLParser.GetAttribute(curChild, "comment");
customTable.strName = tabletype;
customTable.strDotNetName = tabletype;
customTable.strVariableNameInDataset = variablename;
while (customTableNodes != null)
{
if (customTableNodes.Name.ToLower() == "customfield")
{
TTableField customField = new TTableField();
customField.strName = TXMLParser.GetAttribute(customTableNodes, "name");
customField.strTypeDotNet = TXMLParser.GetAttribute(customTableNodes, "type");
customField.strDescription = TXMLParser.GetAttribute(customTableNodes, "comment");
customField.strDefault = TXMLParser.GetAttribute(customTableNodes, "initial");
customTable.grpTableField.Add(customField);
}
if (customTableNodes.Name.ToLower() == "field")
{
// eg. SelectedSiteKey in PartnerEditTDS.MiscellaneousData
TTableField field = new TTableField(store.GetTable(TXMLParser.GetAttribute(customTableNodes, "sqltable")).
GetField(TXMLParser.GetAttribute(customTableNodes, "sqlfield")));
if (TXMLParser.HasAttribute(customTableNodes, "name"))
{
field.strNameDotNet = TXMLParser.GetAttribute(customTableNodes, "name");
}
if (TXMLParser.HasAttribute(customTableNodes, "comment"))
{
field.strDescription = TXMLParser.GetAttribute(customTableNodes, "comment");
}
customTable.grpTableField.Add(field);
}
if (customTableNodes.Name.ToLower() == "primarykey")
{
TConstraint primKeyConstraint = new TConstraint();
primKeyConstraint.strName = "PK";
primKeyConstraint.strType = "primarykey";
primKeyConstraint.strThisFields = StringHelper.StrSplit(TXMLParser.GetAttribute(customTableNodes,
"thisFields"), ",");
customTable.grpConstraint.Add(primKeyConstraint);
}
customTableNodes = customTableNodes.NextSibling;
}
tables.Add(tabletype, customTable);
AddTableToDataset(tabletype, variablename, snippetDataset);
CodeGenerationTable.InsertTableDefinition(snippetDataset, customTable, null, "TABLELOOP");
CodeGenerationTable.InsertRowDefinition(snippetDataset, customTable, null, "TABLELOOP");
}
curChild = curChild.NextSibling;
}
foreach (TDataSetTable table in tables.Values)
{
// todo? also other constraints, not only from original table?
foreach (TConstraint constraint in table.grpConstraint)
{
if ((constraint.strType == "foreignkey") && tables.ContainsKey(constraint.strOtherTable))
{
TDataSetTable otherTable = (TDataSetTable)tables[constraint.strOtherTable];
ProcessTemplate tempSnippet = Template.GetSnippet("INITCONSTRAINTS");
tempSnippet.SetCodelet("TABLEVARIABLENAME1", table.tablealias);
tempSnippet.SetCodelet("TABLEVARIABLENAME2", otherTable.tablealias);
tempSnippet.SetCodelet("CONSTRAINTNAME", TTable.NiceKeyName(constraint));
tempSnippet.SetCodelet("COLUMNNAMES1", StringCollectionToValuesFormattedForArray(constraint.strThisFields));
tempSnippet.SetCodelet("COLUMNNAMES2", StringCollectionToValuesFormattedForArray(constraint.strOtherFields));
snippetDataset.InsertSnippet("INITCONSTRAINTS", tempSnippet);
}
}
}
Template.InsertSnippet("CONTENTDATASETSANDTABLESANDROWS", snippetDataset);
cur = TXMLParser.GetNextEntity(cur);
}
}
Template.FinishWriting(AOutputPath + Path.DirectorySeparatorChar + AFilename + "-generated.cs", ".cs", true);
}
/// <summary>
/// generate code for cascading deletions etc
/// </summary>
/// <param name="AStore"></param>
/// <param name="AFilePath"></param>
/// <param name="ANamespaceName"></param>
/// <param name="AFileName"></param>
/// <returns></returns>
public static Boolean WriteTypedDataCascading(TDataDefinitionStore AStore, string AFilePath, string ANamespaceName, string AFileName)
{
Console.WriteLine("writing namespace " + ANamespaceName);
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
ProcessTemplate Template = new ProcessTemplate(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"DataCascading.cs");
Template.AddToCodelet("NAMESPACE", ANamespaceName);
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(templateDir));
foreach (TTable currentTable in AStore.GetTables())
{
ProcessTemplate snippet = Template.GetSnippet("TABLECASCADING");
if (InsertMainProcedures(AStore, currentTable, Template, snippet))
{
Template.AddToCodelet("USINGNAMESPACES",
CodeGenerationAccess.GetNamespace(currentTable.strGroup), false);
Template.AddToCodelet("USINGNAMESPACES",
CodeGenerationAccess.GetNamespace(currentTable.strGroup).Replace(
".Data;", ".Data.Access;").
Replace("Ict.Petra.Shared.", "Ict.Petra.Server."), false);
Template.InsertSnippet("TABLECASCADINGLOOP", snippet);
}
}
Template.FinishWriting(AFilePath + AFileName + "-generated.cs", ".cs", true);
return true;
}
//other interfaces, e.g. IPartnerUIConnectorsPartnerEdit
// we don't know the interfaces that are implemented, so need to look for the base classes
// we need to know all the source files that are part of the UIConnector dll
private void WriteNamespaces(ProcessTemplate AMainTemplate,
TNamespace tn, SortedList AInterfaceNames, List <CSParser>ACSFiles)
{
AMainTemplate.SetCodelet("MODULE", tn.Name);
foreach (TNamespace sn in tn.Children.Values)
{
ProcessTemplate snippet = AMainTemplate.GetSnippet("SUBNAMESPACE");
snippet.SetCodelet("SUBNAMESPACENAME", sn.Name);
snippet.SetCodelet("SUBNAMESPACEOBJECT", sn.Name);
AMainTemplate.InsertSnippet("SUBNAMESPACES", snippet);
}
// parse Instantiator source code
foreach (TNamespace sn in tn.Children.Values)
{
WriteNamespace(AMainTemplate,
"Ict.Petra.Shared.Interfaces.M" + tn.Name + "." + sn.Name,
sn.Name, tn, sn, sn.Children, AInterfaceNames, ACSFiles);
}
}
private Boolean CreateConnectors(String AOutputPath, String AModulePath, String ATemplateDir)
{
// Work out the module name from the module path
string[] items = AModulePath.Split(new char[] { Path.DirectorySeparatorChar });
if (items.Length == 0)
{
// the -inputclient command line parameter must be wrong
return false;
}
// Module name is e.g. MCommon, MPartner etc
string moduleName = items[items.Length - 1];
// Work out the actual folder/file for the output file
String OutputFolder = AOutputPath + Path.DirectorySeparatorChar + "lib" +
Path.DirectorySeparatorChar + moduleName +
Path.DirectorySeparatorChar + "web";
String OutputFile = OutputFolder + Path.DirectorySeparatorChar + "ReferenceCount-generated.cs";
Console.WriteLine("working on " + OutputFile);
// Where is the template?
String templateFilename = ATemplateDir +
Path.DirectorySeparatorChar + "ORM" +
Path.DirectorySeparatorChar + "ReferenceCountWebConnector.cs";
if (!File.Exists(templateFilename))
{
// The -templatedir command line parameter must have been wrong
return false;
}
// Open the template
ProcessTemplate Template = new ProcessTemplate(templateFilename);
// now we need to remove the leading 'M' from the module name
moduleName = moduleName.Substring(1);
string className = "T" + moduleName + "ReferenceCountWebConnector";
Console.WriteLine("Starting connector for " + className + Environment.NewLine);
int cacheableCount = 0;
int nonCacheableCount = 0;
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(ATemplateDir));
Template.SetCodelet("TOPLEVELMODULE", moduleName);
Template.SetCodelet("CLASSNAME", className);
Template.SetCodelet("CACHEABLETABLECASES", string.Empty);
Template.SetCodelet("CACHEABLETABLENAME", string.Empty);
Template.SetCodelet("CACHEABLETABLECASE", string.Empty);
Template.SetCodelet("CACHEABLETABLELISTNAME", string.Empty);
Template.SetCodelet("CACHEABLETRANSACTION", string.Empty);
Template.SetCodelet("CACHEABLEFINALLY", string.Empty);
Template.SetCodelet("TABLESIF", string.Empty);
Template.SetCodelet("TABLESELSEIF", string.Empty);
Template.SetCodelet("TABLESELSE", string.Empty);
Template.SetCodelet("TABLENAME", string.Empty);
Template.SetCodelet("NONCACHEABLETRANSACTION", string.Empty);
Template.SetCodelet("NONCACHEABLEFINALLY", string.Empty);
// Find all the YAML files in the client module folder
string[] clientFiles = Directory.GetFiles(AModulePath, "*.yaml", SearchOption.AllDirectories);
foreach (String fn in clientFiles)
{
// only look for main files, not language specific files (*.xy-XY.yaml or *.xy.yaml)
if (TProcessYAMLForms.IgnoreLanguageSpecificYamlFile(fn))
{
continue;
}
XmlDocument doc = TYml2Xml.CreateXmlDocument();
SortedList sortedNodes = null;
TCodeStorage codeStorage = new TCodeStorage(doc, sortedNodes);
TParseYAMLFormsDefinition yamlParser = new TParseYAMLFormsDefinition(ref codeStorage);
yamlParser.LoadRecursively(fn, null);
string attDetailTableName = codeStorage.GetAttribute("DetailTable");
string attCacheableListName = codeStorage.GetAttribute("CacheableTable");
// Note - this IF clause needs to be the same as the one in FormWriter.cs which is generating the client side code
// Do Ctrl+F to find: this IF clause needs to be the same
// in that file
if ((attDetailTableName != String.Empty)
&& (codeStorage.FControlList.ContainsKey("btnDelete")
|| codeStorage.FControlList.ContainsKey("btnDeleteType")
|| codeStorage.FControlList.ContainsKey("btnDeleteExtract")
|| codeStorage.FControlList.ContainsKey("btnDeleteDetail")
|| (codeStorage.FControlList.ContainsKey("btnRemoveDetail") && (codeStorage.GetAttribute("FormType") != "report"))))
{
if (attCacheableListName != String.Empty)
{
ProcessTemplate snippet = Template.GetSnippet("CACHEABLETABLECASE");
snippet.SetCodelet("CACHEABLETABLENAME", attDetailTableName);
snippet.SetCodelet("CACHEABLETABLELISTNAME", attCacheableListName);
Template.InsertSnippet("CACHEABLETABLECASES", snippet);
if (cacheableCount == 0)
{
// Add these on the first time through
snippet = Template.GetSnippet("CACHEABLETRANSACTIONSNIP");
Template.InsertSnippet("CACHEABLETRANSACTION", snippet);
snippet = Template.GetSnippet("CACHEABLEFINALLYSNIP");
Template.InsertSnippet("CACHEABLEFINALLY", snippet);
}
Console.WriteLine("Creating cacheable reference count connector for " + attCacheableListName);
cacheableCount++;
}
else
{
ProcessTemplate snippet = null;
if (nonCacheableCount == 0)
{
snippet = Template.GetSnippet("TABLEIF");
snippet.SetCodelet("TABLENAME", attDetailTableName);
Template.InsertSnippet("TABLESIF", snippet);
snippet = Template.GetSnippet("NONCACHEABLETRANSACTIONSNIP");
Template.InsertSnippet("NONCACHEABLETRANSACTION", snippet);
snippet = Template.GetSnippet("NONCACHEABLEFINALLYSNIP");
Template.InsertSnippet("NONCACHEABLEFINALLY", snippet);
}
else
{
snippet = Template.GetSnippet("TABLEELSEIF");
snippet.SetCodelet("TABLENAME", attDetailTableName);
Template.InsertSnippet("TABLESELSEIF", snippet);
}
Console.WriteLine("Creating non-cacheable reference count connector for " + attDetailTableName);
nonCacheableCount++;
}
}
}
// Now we finish off the template content depending on how many entries we made
if ((nonCacheableCount == 0) && (cacheableCount > 0))
{
ProcessTemplate snippet = Template.GetSnippet("TABLENONE");
Template.InsertSnippet("TABLESELSE", snippet);
}
if (nonCacheableCount > 0)
{
ProcessTemplate snippet = Template.GetSnippet("TABLEELSE");
Template.InsertSnippet("TABLESELSE", snippet);
}
if ((cacheableCount > 0) || (nonCacheableCount > 0))
{
if (!Directory.Exists(OutputFolder))
{
// The -outputserver command line parameter must be wrong, or the directory does not exist yet
// Directories must be manually created and added to source code control
Console.WriteLine("Error: directory does not exist: " + OutputFolder);
return false;
}
Console.WriteLine("Finishing connector for " + className + Environment.NewLine + Environment.NewLine);
Template.FinishWriting(OutputFile, ".cs", true);
FTotalCacheable += cacheableCount;
FTotalNonCacheable += nonCacheableCount;
FTotalConnectors++;
}
return true;
}
void ImplementWebConnector(
SortedList <string, TypeDeclaration>connectors,
ProcessTemplate ATemplate, string AFullNamespace)
{
string ConnectorNamespace = AFullNamespace.
Replace("Instantiator.", string.Empty);
List <TypeDeclaration>ConnectorClasses = TCollectConnectorInterfaces.FindTypesInNamespace(connectors, ConnectorNamespace);
ConnectorNamespace = ConnectorNamespace.
Replace("Ict.Petra.Shared.", "Ict.Petra.Server.");
ATemplate.SetCodelet("CLIENTOBJECTFOREACHUICONNECTOR", string.Empty);
foreach (TypeDeclaration connectorClass in ConnectorClasses)
{
foreach (MethodDeclaration m in CSParser.GetMethods(connectorClass))
{
if (TCollectConnectorInterfaces.IgnoreMethod(m.Attributes, m.Modifier))
{
continue;
}
ProcessTemplate snippet = ATemplate.GetSnippet("WEBCONNECTORMETHOD");
string ParameterDefinition = string.Empty;
string ActualParameters = string.Empty;
AutoGenerationTools.FormatParameters(m.Parameters, out ActualParameters, out ParameterDefinition);
snippet.InsertSnippet("CHECKUSERMODULEPERMISSIONS",
CreateModuleAccessPermissionCheck(
ATemplate,
connectorClass.Name,
m));
string returntype = AutoGenerationTools.TypeToString(m.TypeReference, "");
snippet.SetCodelet("RETURN", returntype != "void" ? "return " : string.Empty);
snippet.SetCodelet("METHODNAME", m.Name);
snippet.SetCodelet("ACTUALPARAMETERS", ActualParameters);
snippet.SetCodelet("PARAMETERDEFINITION", ParameterDefinition);
snippet.SetCodelet("RETURNTYPE", returntype);
snippet.SetCodelet("WEBCONNECTORCLASS", connectorClass.Name);
if (!UsingConnectorNamespaces.Contains(ConnectorNamespace))
{
UsingConnectorNamespaces.Add(ConnectorNamespace);
}
ATemplate.InsertSnippet("REMOTEDMETHODS", snippet);
}
}
}
/// <summary>
/// generate code for reading and writing typed data tables from and to the database
/// </summary>
/// <param name="AStore"></param>
/// <param name="strGroup"></param>
/// <param name="AFilePath"></param>
/// <param name="ANamespaceName"></param>
/// <param name="AFilename"></param>
/// <returns></returns>
public static Boolean WriteTypedDataAccess(TDataDefinitionStore AStore,
string strGroup,
string AFilePath,
string ANamespaceName,
string AFilename)
{
Console.WriteLine("processing namespace PetraTypedDataAccess." + strGroup.Substring(0, 1).ToUpper() + strGroup.Substring(1));
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
ProcessTemplate Template = new ProcessTemplate(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"DataAccess.cs");
Template.SetCodelet("NAMESPACE", ANamespaceName);
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(templateDir));
Template.AddToCodelet("USINGNAMESPACES", GetNamespace(strGroup), false);
foreach (TTable currentTable in AStore.GetTables())
{
if (currentTable.strGroup == strGroup)
{
DirectReferences = new ArrayList();
ProcessTemplate snippet = Template.GetSnippet("TABLEACCESS");
InsertMainProcedures(AStore, currentTable, Template, snippet);
InsertViaOtherTable(AStore, currentTable, Template, snippet);
InsertViaLinkTable(AStore, currentTable, Template, snippet);
Template.InsertSnippet("TABLEACCESSLOOP", snippet);
}
}
Template.FinishWriting(AFilePath + AFilename + "-generated.cs", ".cs", true);
return true;
}
void ImplementUIConnector(
SortedList <string, TypeDeclaration>connectors,
ProcessTemplate ATemplate, string AFullNamespace)
{
string ConnectorNamespace = AFullNamespace.
Replace("Instantiator.", string.Empty);
List <TypeDeclaration>ConnectorClasses = TCollectConnectorInterfaces.FindTypesInNamespace(connectors, ConnectorNamespace);
ConnectorNamespace = ConnectorNamespace.
Replace("Ict.Petra.Shared.", "Ict.Petra.Server.");
ATemplate.SetCodelet("CLIENTOBJECTFOREACHUICONNECTOR", string.Empty);
foreach (TypeDeclaration connectorClass in ConnectorClasses)
{
foreach (ConstructorDeclaration m in CSParser.GetConstructors(connectorClass))
{
if (TCollectConnectorInterfaces.IgnoreMethod(m.Attributes, m.Modifier))
{
continue;
}
ProcessTemplate snippet = ATemplate.GetSnippet("UICONNECTORMETHOD");
string ParameterDefinition = string.Empty;
string ActualParameters = string.Empty;
AutoGenerationTools.FormatParameters(m.Parameters, out ActualParameters, out ParameterDefinition);
string methodname = m.Name.Substring(1);
if (methodname.EndsWith("UIConnector"))
{
methodname = methodname.Substring(0, methodname.LastIndexOf("UIConnector"));
}
snippet.SetCodelet("METHODNAME", methodname);
snippet.SetCodelet("PARAMETERDEFINITION", ParameterDefinition);
snippet.SetCodelet("ACTUALPARAMETERS", ActualParameters);
snippet.SetCodelet("UICONNECTORINTERFACE", CSParser.GetImplementedInterface(connectorClass));
snippet.SetCodelet("UICONNECTORCLIENTREMOTINGCLASS", connectorClass.Name + "Remote");
snippet.SetCodelet("UICONNECTORCLASS", connectorClass.Name);
if (!UsingConnectorNamespaces.Contains(ConnectorNamespace))
{
UsingConnectorNamespaces.Add(ConnectorNamespace);
}
ATemplate.InsertSnippet("REMOTEDMETHODS", snippet);
}
List <TypeDeclaration>tempList = new List <TypeDeclaration>();
tempList.Add(connectorClass);
ATemplate.InsertSnippet("CLIENTOBJECTFOREACHUICONNECTOR",
TCreateClientRemotingClass.AddClientRemotingClass(
FTemplateDir,
connectorClass.Name + "Remote",
CSParser.GetImplementedInterface(connectorClass),
tempList
));
}
}
/// <summary>
/// add a string that is translatable
/// </summary>
/// <param name="ACtrlSnippet"></param>
/// <param name="APlaceHolder"></param>
/// <param name="ACtrl"></param>
/// <param name="AText"></param>
public void AddResourceString(ProcessTemplate ACtrlSnippet, string APlaceHolder, TControlDef ACtrl, string AText)
{
string strName;
if (ACtrl == null)
{
strName = APlaceHolder;
}
else
{
strName = ACtrl.controlName + APlaceHolder;
}
ACtrlSnippet.SetCodelet(APlaceHolder, strName);
FTemplate.AddToCodelet("RESOURCESTRINGS", strName + ":'" + AText + "'," + Environment.NewLine);
// write to app-lang-en.js file
FLanguageFileTemplate.AddToCodelet("RESOURCESTRINGS", strName + ":'" + AText + "'," + Environment.NewLine);
}
private void CreateConnectors(TNamespace tn, String AOutputPath, String ATemplateDir)
{
String OutputFile = AOutputPath + Path.DirectorySeparatorChar + "M" + tn.Name +
Path.DirectorySeparatorChar + "Instantiator.Connectors-generated.cs";
if (Directory.Exists(AOutputPath + Path.DirectorySeparatorChar + "M" + tn.Name +
Path.DirectorySeparatorChar + "connect"))
{
OutputFile = AOutputPath + Path.DirectorySeparatorChar + "M" + tn.Name +
Path.DirectorySeparatorChar + "connect" +
Path.DirectorySeparatorChar + "Instantiator.Connectors-generated.cs";
}
Console.WriteLine("working on " + OutputFile);
SortedList <string, TypeDeclaration>connectors = TCollectConnectorInterfaces.GetConnectors(tn.Name);
ProcessTemplate Template = new ProcessTemplate(ATemplateDir + Path.DirectorySeparatorChar +
"ClientServerGlue" + Path.DirectorySeparatorChar +
"Connector.cs");
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(ATemplateDir));
Template.SetCodelet("TOPLEVELMODULE", tn.Name);
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Petra.Shared.Interfaces.M" + tn.Name + ";" + Environment.NewLine);
UsingConnectorNamespaces = new List <string>();
string InterfacePath = Path.GetFullPath(AOutputPath).Replace(Path.DirectorySeparatorChar, '/');
InterfacePath = InterfacePath.Substring(0, InterfacePath.IndexOf("csharp/ICT/Petra")) + "csharp/ICT/Petra/Shared/lib/Interfaces";
Template.AddToCodelet("USINGNAMESPACES", (CreateInterfaces.AddNamespacesFromYmlFile(InterfacePath, tn.Name)));
Template.SetCodelet("CONNECTORCLASSES", string.Empty);
foreach (TNamespace sn in tn.Children.Values)
{
WriteConnectorClass(
Template,
"Ict.Petra.Shared.M" + tn.Name + "." + sn.Name,
sn.Name,
sn.Name,
sn.Children,
connectors);
}
foreach (string n in UsingConnectorNamespaces)
{
Template.AddToCodelet("USINGNAMESPACES", "using " + n + ";" + Environment.NewLine);
}
Template.FinishWriting(OutputFile, ".cs", true);
}
/// based on the code model, create the code;
/// using the code generators that have been loaded
public override void CreateCode(TCodeStorage ACodeStorage, string AXAMLFilename, string ATemplateFile)
{
FCodeStorage = ACodeStorage;
TControlGenerator.FCodeStorage = ACodeStorage;
FTemplate = new ProcessTemplate(ATemplateFile);
FFormName = Path.GetFileNameWithoutExtension(AXAMLFilename).Replace("-", "_");
// drop language specific part of the name
if (FFormName.Contains("."))
{
FFormName = FFormName.Substring(0, FFormName.IndexOf("."));
}
FFormName = FFormName.ToUpper()[0] + FFormName.Substring(1);
FFormName += "Form";
// load default header with license and copyright
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
FTemplate.AddToCodelet("GPLFILEHEADER",
ProcessTemplate.LoadEmptyFileComment(templateDir + Path.DirectorySeparatorChar + ".." +
Path.DirectorySeparatorChar));
FTemplate.SetCodelet("UPLOADFORM", "");
FTemplate.SetCodelet("CHECKFORVALIDUPLOAD", "");
FLanguageFileTemplate = FTemplate.GetSnippet("LANGUAGEFILE");
// find the first control that is a panel or groupbox or tab control
if (FCodeStorage.HasRootControl("content"))
{
AddRootControl("content");
}
InsertCodeIntoTemplate(AXAMLFilename);
string languagefilepath = Path.GetDirectoryName(AXAMLFilename) + Path.DirectorySeparatorChar +
Path.GetFileNameWithoutExtension(AXAMLFilename) + "-lang-template.js";
File.WriteAllText(languagefilepath, FLanguageFileTemplate.FinishWriting(true));
}
//other interfaces, e.g. IPartnerUIConnectorsPartnerEdit
// we don't know the interfaces that are implemented, so need to look for the base classes
// we need to know all the source files that are part of the UIConnector dll
private void WriteNamespaces(ProcessTemplate AMainTemplate,
TNamespace tn, SortedList AInterfaceNames, List <CSParser>ACSFiles)
{
AMainTemplate.SetCodelet("MODULE", tn.Name);
// parse Instantiator source code
foreach (TNamespace sn in tn.Children.Values)
{
WriteNamespace(AMainTemplate,
"Ict.Petra.Shared.Interfaces.M" + tn.Name + "." + sn.Name,
sn.Name, tn, sn, sn.Children, AInterfaceNames, ACSFiles);
}
}
private static void PrepareParametersForMethod(
ProcessTemplate snippet,
TypeReference AReturnType,
List <ParameterDeclarationExpression>AParameters,
string AMethodName,
ref List <string>AMethodNames)
{
string ParameterDefinition = string.Empty;
string ActualParameters = string.Empty;
snippet.SetCodelet("LOCALVARIABLES", string.Empty);
string returnCodeFatClient = string.Empty;
string returnCodeJSClient = string.Empty;
int returnCounter = 0;
foreach (ParameterDeclarationExpression p in AParameters)
{
string parametertype = p.TypeReference.ToString();
bool ArrayParameter = false;
// check if the parametertype is not a generic type, eg. dictionary or list
if (!parametertype.Contains("<"))
{
if (parametertype.EndsWith("[]"))
{
ArrayParameter = true;
//Console.WriteLine("ArrayParameter found: " + parametertype);
}
parametertype = parametertype == "string" || parametertype == "String" ? "System.String" : parametertype;
parametertype = parametertype == "bool" || parametertype == "Boolean" ? "System.Boolean" : parametertype;
if (parametertype.Contains("UINT") || parametertype.Contains("unsigned"))
{
parametertype = parametertype.Contains("UInt32") || parametertype == "unsigned int" ? "System.UInt32" : parametertype;
parametertype = parametertype.Contains("UInt16") || parametertype == "unsigned short" ? "System.UInt16" : parametertype;
parametertype = parametertype.Contains("UInt64") || parametertype == "unsigned long" ? "System.UInt64" : parametertype;
}
else
{
parametertype = parametertype.Contains("Int32") || parametertype == "int" ? "System.Int32" : parametertype;
parametertype = parametertype.Contains("Int16") || parametertype == "short" ? "System.Int16" : parametertype;
parametertype = parametertype.Contains("Int64") || parametertype == "long" ? "System.Int64" : parametertype;
}
parametertype = parametertype.Contains("Decimal") || parametertype == "decimal" ? "System.Decimal" : parametertype;
if (ArrayParameter
&& !(parametertype.EndsWith("[]")))
{
// need to restore Array type!
parametertype += "[]";
//Console.WriteLine("ArrayParameter found - new parametertype = " + parametertype);
}
}
bool EnumParameter = parametertype.EndsWith("Enum");
bool BinaryParameter =
!((parametertype.StartsWith("System.Int64")) || (parametertype.StartsWith("System.Int32"))
|| (parametertype.StartsWith("System.Int16"))
|| (parametertype.StartsWith("System.String")) || (parametertype.StartsWith("System.Boolean"))
|| EnumParameter);
if (ActualParameters.Length > 0)
{
ActualParameters += ", ";
}
// ignore out parameters in the web service method definition
if ((ParameterModifiers.Out & p.ParamModifier) == 0)
{
if (ParameterDefinition.Length > 0)
{
ParameterDefinition += ", ";
}
if ((!BinaryParameter) && (!ArrayParameter) && (!EnumParameter))
{
ParameterDefinition += parametertype + " " + p.ParameterName;
}
else
{
ParameterDefinition += "string " + p.ParameterName;
}
}
// for string parameters, check if they have been encoded binary due to special characters in the string;
// this obviously does not apply to out parameters
if ((parametertype == "System.String") && ((ParameterModifiers.Out & p.ParamModifier) == 0))
{
snippet.AddToCodelet(
"LOCALVARIABLES",
p.ParameterName + " = (string) THttpBinarySerializer.DeserializeObject(" + p.ParameterName + ",\"System.String\");" +
Environment.NewLine);
}
// EnumParameters are also binary encoded
// this obviously does not apply to out parameters
if (EnumParameter && ((ParameterModifiers.Out & p.ParamModifier) == 0))
{
snippet.AddToCodelet(
"LOCALVARIABLES",
p.ParameterName + " = THttpBinarySerializer.DeserializeObject(" + p.ParameterName + ",\"System.String\").ToString();" +
Environment.NewLine);
}
if ((ParameterModifiers.Out & p.ParamModifier) != 0)
{
snippet.AddToCodelet("LOCALVARIABLES", parametertype + " " + p.ParameterName + ";" + Environment.NewLine);
ActualParameters += "out " + p.ParameterName;
}
else if ((ParameterModifiers.Ref & p.ParamModifier) != 0)
{
if (BinaryParameter)
{
snippet.AddToCodelet("LOCALVARIABLES", parametertype + " Local" + p.ParameterName + " = " +
" (" + parametertype + ")THttpBinarySerializer.DeserializeObject(" + p.ParameterName + ",\"binary\");" +
Environment.NewLine);
ActualParameters += "ref Local" + p.ParameterName;
}
else if (EnumParameter)
{
snippet.AddToCodelet("LOCALVARIABLES", parametertype + " Local" + p.ParameterName + " = " +
" (" + parametertype + ") Enum.Parse(typeof(" + parametertype + "), " + p.ParameterName + ");" +
Environment.NewLine);
ActualParameters += "ref Local" + p.ParameterName;
}
else
{
ActualParameters += "ref " + p.ParameterName;
}
}
else
{
if (BinaryParameter
|| ArrayParameter)
{
ActualParameters += "(" + parametertype + ")THttpBinarySerializer.DeserializeObject(" + p.ParameterName + ",\"binary\")";
}
else if (EnumParameter)
{
ActualParameters += " (" + parametertype + ") Enum.Parse(typeof(" + parametertype + "), " + p.ParameterName + ")";
}
else
{
ActualParameters += p.ParameterName;
}
}
if (((ParameterModifiers.Ref & p.ParamModifier) > 0) || ((ParameterModifiers.Out & p.ParamModifier) > 0))
{
returnCodeFatClient +=
(returnCodeFatClient.Length > 0 ? "+\",\"+" : string.Empty) +
"THttpBinarySerializer.SerializeObjectWithType(" +
(((ParameterModifiers.Ref & p.ParamModifier) > 0 && BinaryParameter) ? "Local" : string.Empty) +
p.ParameterName + ")";
if (returnCounter == 1)
{
returnCodeJSClient = "\"{ \\\"0\\\": \" + " + returnCodeJSClient;
}
if (returnCounter > 0)
{
returnCodeJSClient += " + \", \\\"" + returnCounter.ToString() + "\\\": \" + ";
}
returnCodeJSClient +=
"THttpBinarySerializer.SerializeObjectWithType(" +
(((ParameterModifiers.Ref & p.ParamModifier) > 0 && BinaryParameter) ? "Local" : string.Empty) +
p.ParameterName + ")";
returnCounter++;
}
}
if (AReturnType != null)
{
string returntype = AutoGenerationTools.TypeToString(AReturnType, "");
if (!returntype.Contains("<"))
{
returntype = returntype == "string" || returntype == "String" ? "System.String" : returntype;
returntype = returntype == "bool" || returntype == "Boolean" ? "System.Boolean" : returntype;
if (returntype.Contains("UINT") || returntype.Contains("unsigned"))
{
returntype = returntype.Contains("UInt32") || returntype == "unsigned int" ? "System.UInt32" : returntype;
returntype = returntype.Contains("UInt16") || returntype == "unsigned short" ? "System.UInt16" : returntype;
returntype = returntype.Contains("UInt64") || returntype == "unsigned long" ? "System.UInt64" : returntype;
}
else
{
returntype = returntype.Contains("Int32") || returntype == "int" ? "System.Int32" : returntype;
returntype = returntype.Contains("Int16") || returntype == "short" ? "System.Int16" : returntype;
returntype = returntype.Contains("Int64") || returntype == "long" ? "System.Int64" : returntype;
}
returntype = returntype.Contains("Decimal") || returntype == "decimal" ? "System.Decimal" : returntype;
}
if (returnCounter > 0)
{
if (returntype != "void")
{
returnCodeFatClient +=
(returnCodeFatClient.Length > 0 ? "+\",\"+" : string.Empty) + "THttpBinarySerializer.SerializeObjectWithType(Result)";
if (returnCounter == 1)
{
returnCodeJSClient = "\"{ \\\"0\\\": \" + " + returnCodeJSClient;
}
returnCodeJSClient += "+\", \\\"" + returnCounter.ToString() + "\\\": \"+" +
"THttpBinarySerializer.SerializeObjectWithType(Result)";
returnCounter++;
}
returntype = "string";
}
else if (returntype == "System.String")
{
returntype = "string";
returnCodeFatClient = "THttpBinarySerializer.SerializeObjectWithType(Result)";
returnCodeJSClient = "Result";
}
else if (!((returntype == "System.Int64") || (returntype == "System.Int32") || (returntype == "System.Int16")
|| (returntype == "System.UInt64") || (returntype == "System.UInt32") || (returntype == "System.UInt16")
|| (returntype == "System.Decimal")
|| (returntype == "System.Boolean")) && (returntype != "void"))
{
returntype = "string";
returnCodeFatClient = returnCodeJSClient = "THttpBinarySerializer.SerializeObject(Result)";
}
string localreturn = AutoGenerationTools.TypeToString(AReturnType, "");
if (localreturn == "void")
{
localreturn = string.Empty;
}
else if ((returnCodeFatClient.Length > 0) || (returnCodeJSClient.Length > 0))
{
localreturn += " Result = ";
}
else
{
localreturn = "return ";
}
if (returnCounter > 1)
{
returnCodeJSClient += "+ \"}\"";
}
snippet.SetCodelet("RETURN", string.Empty);
if ((returnCodeFatClient.Length > 0) || (returnCodeJSClient.Length > 0))
{
snippet.SetCodelet("RETURN",
returntype != "void" ? "return isJSClient()?" + returnCodeJSClient + ":" + returnCodeFatClient + ";" : string.Empty);
}
snippet.SetCodelet("RETURNTYPE", returntype);
snippet.SetCodelet("LOCALRETURN", localreturn);
}
//Console.WriteLine("Final ParameterDefinition = " + ParameterDefinition);
snippet.SetCodelet("PARAMETERDEFINITION", ParameterDefinition);
snippet.SetCodelet("ACTUALPARAMETERS", ActualParameters);
// avoid duplicate names for webservice methods
string methodname = AMethodName;
int methodcounter = 1;
while (AMethodNames.Contains(methodname))
{
methodcounter++;
methodname = AMethodName + methodcounter.ToString();
}
AMethodNames.Add(methodname);
snippet.SetCodelet("UNIQUEMETHODNAME", methodname);
}
/// <summary>
/// use CSParser to parse the Server files
/// </summary>
/// <param name="tn"></param>
/// <param name="AOutputPath"></param>
private void WriteInterfaces(TNamespace tn, String AOutputPath)
{
String OutputFile = AOutputPath + Path.DirectorySeparatorChar + tn.Name + ".Interfaces-generated.cs";
// open file
Console.WriteLine("working on file " + OutputFile);
ProcessTemplate Template = new ProcessTemplate(FTemplateDir + Path.DirectorySeparatorChar +
"ClientServerGlue" + Path.DirectorySeparatorChar +
"Interface.cs");
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(FTemplateDir));
Template.AddToCodelet("USINGNAMESPACES", AddNamespacesFromYmlFile(AOutputPath, tn.Name));
// get all csharp files that might hold implementations of remotable classes
List <CSParser>CSFiles = null;
if (AOutputPath.Contains("ICT/Petra/Plugins"))
{
// search for webconnectors in the directory of the plugin
CSFiles = CSParser.GetCSFilesForDirectory(Path.GetFullPath(AOutputPath + "/../Server"),
SearchOption.AllDirectories);
}
else if (Directory.Exists(CSParser.ICTPath + "/Petra/Server/lib/M" + tn.Name))
{
// any class in the module can contain a webconnector
CSFiles = CSParser.GetCSFilesForDirectory(CSParser.ICTPath + "/Petra/Server/lib/M" + tn.Name,
SearchOption.AllDirectories);
}
else
{
CSFiles = new List <CSParser>();
}
SortedList InterfaceNames = GetInterfaceNamesFromImplementation(CSFiles);
Template.SetCodelet("INTERFACES", string.Empty);
WriteNamespaces(Template, tn, InterfaceNames, CSFiles);
if (Template.FCodelets["INTERFACES"].Length == 0)
{
Template.InsertSnippet("INTERFACES", Template.GetSnippet("DUMMYINTERFACE"));
}
Template.FinishWriting(OutputFile, ".cs", true);
}
static private void CreateServerGlue(TNamespace tn, SortedList <string, TypeDeclaration>connectors, string AOutputPath)
{
String OutputFile = AOutputPath + Path.DirectorySeparatorChar + "ServerGlue.M" + tn.Name +
"-generated.cs";
Console.WriteLine("working on " + OutputFile);
ProcessTemplate Template = new ProcessTemplate(FTemplateDir + Path.DirectorySeparatorChar +
"ClientServerGlue" + Path.DirectorySeparatorChar +
"ServerGlue.cs");
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(FTemplateDir));
Template.SetCodelet("TOPLEVELMODULE", tn.Name);
Template.SetCodelet("WEBCONNECTORS", string.Empty);
Template.SetCodelet("UICONNECTORS", string.Empty);
string InterfacePath = Path.GetFullPath(AOutputPath).Replace(Path.DirectorySeparatorChar, '/');
InterfacePath = InterfacePath.Substring(0, InterfacePath.IndexOf("csharp/ICT/Petra")) + "csharp/ICT/Petra/Shared/lib/Interfaces";
Template.AddToCodelet("USINGNAMESPACES", CreateInterfaces.AddNamespacesFromYmlFile(InterfacePath, tn.Name));
if (AOutputPath.Contains("ICT/Petra/Plugins/"))
{
Template.AddToCodelet("USINGNAMESPACES", "using Ict.Petra.Server.App.WebService;" + Environment.NewLine);
// add namespaces that are required by the plugin
InterfacePath = Path.GetFullPath(AOutputPath + "/../").Replace(Path.DirectorySeparatorChar, '/');
Template.AddToCodelet("USINGNAMESPACES", CreateInterfaces.AddNamespacesFromYmlFile(InterfacePath, "Plugin"));
}
FUsingNamespaces = new SortedList <string, string>();
FContainsAsynchronousExecutionProgress = false;
foreach (string connector in connectors.Keys)
{
if (connector.Contains(":"))
{
WriteUIConnector(connector, connectors[connector], Template);
}
else
{
WriteWebConnector(connector, connectors[connector], Template);
}
}
if (FContainsAsynchronousExecutionProgress)
{
Template.InsertSnippet("UICONNECTORS", Template.GetSnippet("ASYNCEXECPROCESSCONNECTOR"));
if (!FUsingNamespaces.ContainsKey("Ict.Petra.Server.MCommon"))
{
FUsingNamespaces.Add("Ict.Petra.Server.MCommon", "Ict.Petra.Server.MCommon");
}
}
foreach (string usingNamespace in FUsingNamespaces.Keys)
{
Template.AddToCodelet("USINGNAMESPACES", "using " + usingNamespace + ";" + Environment.NewLine);
}
if (OutputFile.Replace("\\", "/").Contains("ICT/Petra/Plugins"))
{
string pluginWithNamespace = TAppSettingsManager.GetValue("plugin");
Template.SetCodelet("WEBSERVICENAMESPACE", pluginWithNamespace + ".WebService");
}
else
{
Template.SetCodelet("WEBSERVICENAMESPACE", "Ict.Petra.Server.App.WebService");
}
Template.FinishWriting(OutputFile, ".cs", true);
}
/// <summary>
/// create the code for validation of a typed table
/// </summary>
/// <param name="AStore"></param>
/// <param name="strGroup"></param>
/// <param name="AFilePath"></param>
/// <param name="ANamespaceName"></param>
/// <param name="AFileName"></param>
/// <returns></returns>
public static Boolean WriteValidation(TDataDefinitionStore AStore, string strGroup, string AFilePath, string ANamespaceName, string AFileName)
{
Console.WriteLine("processing validation of Typed Tables " + strGroup.Substring(0, 1).ToUpper() + strGroup.Substring(1));
string templateDir = TAppSettingsManager.GetValue("TemplateDir", true);
ProcessTemplate Template = new ProcessTemplate(templateDir + Path.DirectorySeparatorChar +
"ORM" + Path.DirectorySeparatorChar +
"DataTableValidation.cs");
Template.AddToCodelet("NAMESPACE", ANamespaceName);
Template.AddToCodelet("DATATABLENAMESPACE", ANamespaceName.Replace("Validation", "Data"));
// load default header with license and copyright
Template.SetCodelet("GPLFILEHEADER", ProcessTemplate.LoadEmptyFileComment(templateDir));
foreach (TTable currentTable in AStore.GetTables())
{
if (currentTable.strGroup == strGroup)
{
InsertTableValidation(Template, currentTable, null, "TABLELOOP");
}
}
if (!Directory.Exists(AFilePath))
{
Directory.CreateDirectory(AFilePath);
}
Template.FinishWriting(AFilePath + AFileName + "-generated.cs", ".cs", true);
return true;
}