private ProcessTemplate WriteLoaderClass(ProcessTemplate ATemplate, String module) { ProcessTemplate loaderClassSnippet = ATemplate.GetSnippet("LOADERCLASS"); loaderClassSnippet.SetCodelet("MODULE", module); return loaderClassSnippet; }
/// <summary> /// generate the objects that can be serialized to the client /// </summary> public static ProcessTemplate AddClientRemotingClass( string ATemplateDir, string AClientObjectClass, string AInterfaceName, List <TypeDeclaration>ATypeImplemented, string AFullNamespace = "", SortedList <string, TNamespace>AChildrenNamespaces = null) { if (ClientRemotingClassTemplate == null) { ClientRemotingClassTemplate = new ProcessTemplate(ATemplateDir + Path.DirectorySeparatorChar + "ClientServerGlue" + Path.DirectorySeparatorChar + "ClientRemotingClass.cs"); } ProcessTemplate snippet = ClientRemotingClassTemplate.GetSnippet("CLASS"); snippet.SetCodelet("CLASSNAME", AClientObjectClass); snippet.SetCodelet("INTERFACE", AInterfaceName); // try to implement the properties and methods defined in the interface snippet.SetCodelet("METHODSANDPROPERTIES", string.Empty); // problem mit Partner.Extracts.UIConnectors; MCommon.UIConnectors tut if (AChildrenNamespaces != null) { // accessors for subnamespaces InsertSubnamespaces(snippet, AFullNamespace, AChildrenNamespaces); } else { foreach (TypeDeclaration t in ATypeImplemented) { if (t.UserData.ToString().EndsWith("UIConnectors")) { if (AInterfaceName.EndsWith("Namespace")) { InsertConstructors(snippet, t); } else { // never gets here??? InsertMethodsAndProperties(snippet, t); } } if (t.UserData.ToString().EndsWith("WebConnectors")) { InsertMethodsAndProperties(snippet, t); } } } return snippet; }
/// <summary> /// write the code for reading and writing the controls with the parameters /// </summary> public static void GenerateReadSetControls(TFormWriter writer, XmlNode curNode, ProcessTemplate ATargetTemplate, string ATemplateControlType) { string controlName = curNode.Name; // check if this control is already part of an optional group of controls depending on a radiobutton TControlDef ctrl = writer.CodeStorage.GetControl(controlName); if (ctrl.GetAttribute("DependsOnRadioButton") == "true") { return; } if (ctrl.GetAttribute("NoParameter") == "true") { return; } string paramName = ReportControls.GetParameterName(curNode); if (paramName == null) { return; } bool clearIfSettingEmpty = ReportControls.GetClearIfSettingEmpty(curNode); ProcessTemplate snippetReadControls = writer.Template.GetSnippet(ATemplateControlType + "READCONTROLS"); snippetReadControls.SetCodelet("CONTROLNAME", controlName); snippetReadControls.SetCodelet("PARAMNAME", paramName); ATargetTemplate.InsertSnippet("READCONTROLS", snippetReadControls); ProcessTemplate snippetWriteControls = writer.Template.GetSnippet(ATemplateControlType + "SETCONTROLS"); snippetWriteControls.SetCodelet("CONTROLNAME", controlName); snippetWriteControls.SetCodelet("PARAMNAME", paramName); if (clearIfSettingEmpty) { snippetWriteControls.SetCodelet("CLEARIFSETTINGEMPTY", clearIfSettingEmpty.ToString().ToLower()); } ATargetTemplate.InsertSnippet("SETCONTROLS", snippetWriteControls); }
/// <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 the snippet into the current template, into the given codelet. /// add new text in front of the text that has already been added to the codelet /// </summary> /// <param name="ACodeletName"></param> /// <param name="ASnippet"></param> public void InsertSnippetPrepend(string ACodeletName, ProcessTemplate ASnippet) { ASnippet.ReplaceCodelets(); if (FCodelets.ContainsKey(ACodeletName)) { AddToCodeletPrepend(ACodeletName, ASnippet.FTemplateCode.ToString() + Environment.NewLine); } else { AddToCodeletPrepend(ACodeletName, ASnippet.FTemplateCode.ToString()); } }
/// <summary> /// insert the snippet into the current template, into the given codelet /// </summary> /// <param name="ACodeletName"></param> /// <param name="ASnippet"></param> public void InsertSnippet(string ACodeletName, ProcessTemplate ASnippet) { ASnippet.ReplaceCodelets(); ASnippet.ProcessIFDEFs(ref ASnippet.FTemplateCode); ASnippet.ProcessIFNDEFs(ref ASnippet.FTemplateCode); if (FCodelets.ContainsKey(ACodeletName) && !FCodelets[ACodeletName].ToString().EndsWith(Environment.NewLine) && (FCodelets[ACodeletName].Length > 0)) { AddToCodelet(ACodeletName, Environment.NewLine); } AddToCodelet(ACodeletName, ASnippet.FTemplateCode.ToString()); }
/// <summary> /// add snippets from another template file /// (eg. for writing datasets, we want to reuse the table template for custom tables) /// </summary> /// <param name="AFilePath"></param> public void AddSnippetsFromOtherFile(string AFilePath) { ProcessTemplate temp = new ProcessTemplate(AFilePath); foreach (string key in temp.FSnippets.Keys) { // don't overwrite own snippets with same name if (!this.FSnippets.ContainsKey(key)) { this.FSnippets.Add(key, (string)temp.FSnippets[key]); } } }
static private ProcessTemplate CreateModuleAccessPermissionCheck(ProcessTemplate ATemplate, string AConnectorClassWithNamespace, MethodDeclaration m) { if (m.Attributes != null) { foreach (AttributeSection attrSection in m.Attributes) { foreach (ICSharpCode.NRefactory.Ast.Attribute attr in attrSection.Attributes) { if (attr.Name == "RequireModulePermission") { ProcessTemplate snippet = ATemplate.GetSnippet("CHECKUSERMODULEPERMISSIONS"); snippet.SetCodelet("METHODNAME", m.Name); snippet.SetCodelet("CONNECTORWITHNAMESPACE", AConnectorClassWithNamespace); snippet.SetCodelet("LEDGERNUMBER", ""); string ParameterTypes = ";"; foreach (ParameterDeclarationExpression p in m.Parameters) { if (p.ParameterName == "ALedgerNumber") { snippet.SetCodelet("LEDGERNUMBER", ", ALedgerNumber"); } string ParameterType = p.TypeReference.Type.Replace("&", "").Replace("System.", String.Empty); if (ParameterType == "List") { ParameterType = ParameterType.Replace("List", "List[" + p.TypeReference.GenericTypes[0].ToString() + "]"); ParameterType = ParameterType.Replace("System.", String.Empty); } if (ParameterType == "Dictionary") { ParameterType = ParameterType.Replace("Dictionary", "Dictionary[" + p.TypeReference.GenericTypes[0].ToString() + "," + p.TypeReference.GenericTypes[1].ToString() + "]"); ParameterType = ParameterType.Replace("System.", String.Empty); } if (ParameterType.Contains(".")) { ParameterType = ParameterType.Substring(ParameterType.LastIndexOf(".") + 1); } if (p.TypeReference.Type == "System.Nullable") { ParameterType = ParameterType.Replace("Nullable", "Nullable[" + p.TypeReference.GenericTypes[0].ToString() + "]"); } if (p.TypeReference.IsArrayType) { ParameterType += ".ARRAY"; } // if (ParameterType == "SortedList") // { //Console.WriteLine(p.ParameterName + "'s ParameterType = SortedList"); // ParameterType = ParameterType.Replace("List", "List[" + // p.TypeReference.GenericTypes[0].ToString() + "," + // p.TypeReference.GenericTypes[1].ToString() + "]"); // ParameterType = ParameterType.Replace("System.", String.Empty); // } ParameterType = ParameterType.Replace("Boolean", "bool"); ParameterType = ParameterType.Replace("Int32", "int"); ParameterType = ParameterType.Replace("Int64", "long"); ParameterTypes += ParameterType + ";"; } ParameterTypes = ParameterTypes.ToUpper(); snippet.SetCodelet("PARAMETERTYPES", ParameterTypes); return snippet; } else if (attr.Name == "CheckServerAdminToken") { ProcessTemplate snippet = ATemplate.GetSnippet("CHECKSERVERADMINPERMISSION"); string paramdefinition = "string AServerAdminSecurityToken"; if (ATemplate.FCodelets["PARAMETERDEFINITION"].Length != 0) { paramdefinition += ", "; } ATemplate.AddToCodeletPrepend("PARAMETERDEFINITION", paramdefinition); return snippet; } } } } TLogging.Log("Warning !!! Missing module access permissions for " + AConnectorClassWithNamespace + "::" + m.Name); return new ProcessTemplate(); }
static private void WriteWebConnector(string connectorname, TypeDeclaration connectorClass, ProcessTemplate Template) { List <string>MethodNames = new List <string>(); foreach (MethodDeclaration m in CSParser.GetMethods(connectorClass)) { if (TCollectConnectorInterfaces.IgnoreMethod(m.Attributes, m.Modifier)) { continue; } string connectorNamespaceName = ((NamespaceDeclaration)connectorClass.Parent).Name; if (!FUsingNamespaces.ContainsKey(connectorNamespaceName)) { FUsingNamespaces.Add(connectorNamespaceName, connectorNamespaceName); } ProcessTemplate snippet = Template.GetSnippet("WEBCONNECTOR"); InsertWebConnectorMethodCall(snippet, connectorClass, m, ref MethodNames); Template.InsertSnippet("WEBCONNECTORS", snippet); } }
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> /// 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; }
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; } } }
/// <summary> /// situation 2: bridging tables /// for example p_location and p_partner are connected through p_partner_location /// it would be helpful, to be able to do: /// location.LoadViaPartner(partnerkey) to get all locations of the partner /// partner.loadvialocation(locationkey) to get all partners living at that location /// general solution: pick up all foreign keys from other tables (B) to the primary key of the current table (A), /// where the other table has a foreign key to another table (C), using other fields in the primary key of (B) than the link to (A). /// get all tables that reference the current table /// </summary> /// <param name="AStore"></param> /// <param name="ACurrentTable"></param> /// <param name="ATemplate"></param> /// <param name="ASnippet"></param> private static void InsertViaLinkTable(TDataDefinitionStore AStore, TTable ACurrentTable, ProcessTemplate ATemplate, ProcessTemplate ASnippet) { // step 1: collect all the valid constraints of such link tables ArrayList OtherLinkConstraints = new ArrayList(); ArrayList References = new ArrayList(); foreach (TConstraint Reference in ACurrentTable.GetReferences()) { TTable LinkTable = AStore.GetTable(Reference.strThisTable); try { TConstraint LinkPrimaryKey = LinkTable.GetPrimaryKey(); if (StringHelper.Contains(LinkPrimaryKey.strThisFields, Reference.strThisFields)) { // check how many constraints from the link table are from fields in the primary key // a link table only should have 2 // so find the other one TConstraint OtherLinkConstraint = null; bool IsLinkTable = false; foreach (TConstraint LinkConstraint in LinkTable.grpConstraint) { // check if there is another constraint for the primary key of the link table. if (ValidForeignKeyConstraintForLoadVia(LinkConstraint) && (LinkConstraint != Reference) && (StringHelper.Contains(LinkPrimaryKey.strThisFields, LinkConstraint.strThisFields))) { if (OtherLinkConstraint == null) { OtherLinkConstraint = LinkConstraint; IsLinkTable = true; } else { IsLinkTable = false; } } else if (ValidForeignKeyConstraintForLoadVia(LinkConstraint) && (LinkConstraint != Reference) && (!StringHelper.Contains(LinkPrimaryKey.strThisFields, LinkConstraint.strThisFields)) && StringHelper.ContainsSome(LinkPrimaryKey.strThisFields, LinkConstraint.strThisFields)) { // if there is a key that partly is in the primary key, then this is not a link table. OtherLinkConstraint = LinkConstraint; IsLinkTable = false; } } if ((IsLinkTable) && (OtherLinkConstraint.strOtherTable != Reference.strOtherTable)) { // collect the links. then we are able to name them correctly, once we need them OtherLinkConstraints.Add(OtherLinkConstraint); References.Add(Reference); } } } catch (Exception) { // Console.WriteLine(e.Message); } } // step2: implement the link tables, using correct names for the procedures int Count = 0; foreach (TConstraint OtherLinkConstraint in OtherLinkConstraints) { TTable OtherTable = AStore.GetTable(OtherLinkConstraint.strOtherTable); string ProcedureName = "Via" + TTable.NiceTableName(OtherTable.strName); // check if other foreign key exists that references the same table, e.g. // PPartnerAccess.LoadViaSUserPRecentPartners // PPartnerAccess.LoadViaSUserPCustomisedGreeting // also PFoundationProposalAccess.LoadViaPFoundationPFoundationProposalDetail and // TODO AlreadyExistsProcedureSameName necessary for PPersonAccess.LoadViaPUnit (p_field_key_n) and PPersonAccess.LoadViaPUnitPmGeneralApplication // Question: does PPersonAccess.LoadViaPUnitPmGeneralApplication make sense? if (FindOtherConstraintSameOtherTable2(OtherLinkConstraints, OtherLinkConstraint) || LoadViaHasAlreadyBeenImplemented(OtherLinkConstraint) // TODO || AlreadyExistsProcedureSameName(ProcedureName) || ((ProcedureName == "ViaPUnit") && (OtherLinkConstraint.strThisTable == "pm_general_application")) ) { ProcedureName += TTable.NiceTableName(OtherLinkConstraint.strThisTable); } ATemplate.AddToCodelet("USINGNAMESPACES", GetNamespace(OtherTable.strGroup), false); ProcessTemplate snippetLinkTable = ATemplate.GetSnippet("VIALINKTABLE"); snippetLinkTable.SetCodelet("VIAPROCEDURENAME", ProcedureName); snippetLinkTable.SetCodelet("OTHERTABLENAME", TTable.NiceTableName(OtherTable.strName)); snippetLinkTable.SetCodelet("SQLOTHERTABLENAME", OtherTable.strName); snippetLinkTable.SetCodelet("SQLLINKTABLENAME", OtherLinkConstraint.strThisTable); string notUsed; int notUsedInt; string formalParametersOtherPrimaryKey; string actualParametersOtherPrimaryKey; PrepareCodeletsPrimaryKey(OtherTable, out formalParametersOtherPrimaryKey, out actualParametersOtherPrimaryKey, out notUsed, out notUsedInt); PrepareCodeletsPrimaryKey(ACurrentTable, out notUsed, out notUsed, out notUsed, out notUsedInt); string whereClauseForeignKey; string whereClauseViaOtherTable; string odbcParametersForeignKey; PrepareCodeletsForeignKey( OtherTable, OtherLinkConstraint, out whereClauseForeignKey, out whereClauseViaOtherTable, out odbcParametersForeignKey, out notUsedInt, out notUsed); string whereClauseViaLinkTable; string whereClauseAllViaTables; PrepareCodeletsViaLinkTable( (TConstraint)References[Count], OtherLinkConstraint, out whereClauseViaLinkTable, out whereClauseAllViaTables); snippetLinkTable.SetCodelet("FORMALPARAMETERSOTHERPRIMARYKEY", formalParametersOtherPrimaryKey); snippetLinkTable.SetCodelet("ACTUALPARAMETERSOTHERPRIMARYKEY", actualParametersOtherPrimaryKey); snippetLinkTable.SetCodelet("ODBCPARAMETERSFOREIGNKEY", odbcParametersForeignKey); snippetLinkTable.SetCodelet("WHERECLAUSEVIALINKTABLE", whereClauseViaLinkTable); snippetLinkTable.SetCodelet("WHERECLAUSEALLVIATABLES", whereClauseAllViaTables); ASnippet.InsertSnippet("VIALINKTABLE", snippetLinkTable); Count = Count + 1; } }
/// <summary> /// this is for foreign keys, eg load all countries with currency EUR /// </summary> /// <param name="AStore"></param> /// <param name="ACurrentTable"></param> /// <param name="ATemplate"></param> /// <param name="ASnippet"></param> private static void InsertViaOtherTable(TDataDefinitionStore AStore, TTable ACurrentTable, ProcessTemplate ATemplate, ProcessTemplate ASnippet) { foreach (TConstraint myConstraint in ACurrentTable.grpConstraint) { if (ValidForeignKeyConstraintForLoadVia(myConstraint)) { TTable OtherTable = AStore.GetTable(myConstraint.strOtherTable); if (!LoadViaHasAlreadyBeenImplemented(myConstraint)) { InsertViaOtherTableConstraint(AStore, myConstraint, ACurrentTable, OtherTable, ATemplate, ASnippet); } // AccountHierarchy: there is no constraint that references Ledger directly, but constraint referencing the Account table with a key that contains the ledger reference // but because the key in Ledger is already the primary key, a LoadViaLedger is required. // other way round: p_foundation_proposal_detail has 2 constraints for foundation and foundationproposal foreach (string field in myConstraint.strOtherFields) { // get a constraint that is only based on that field TConstraint OtherLinkConstraint = OtherTable.GetConstraint(StringHelper.StrSplit(field, ",")); if ((OtherLinkConstraint != null) && ValidForeignKeyConstraintForLoadVia(OtherLinkConstraint)) { TConstraint NewConstraint = new TConstraint(); NewConstraint.strName = OtherLinkConstraint.strName + "forLoadVia"; NewConstraint.strType = "foreignkey"; NewConstraint.strThisTable = myConstraint.strThisTable; NewConstraint.strThisFields = StringHelper.StrSplit(myConstraint.strThisFields[myConstraint.strOtherFields.IndexOf( field)], ","); NewConstraint.strOtherTable = OtherLinkConstraint.strOtherTable; NewConstraint.strOtherFields = OtherLinkConstraint.strOtherFields; if (!LoadViaHasAlreadyBeenImplemented(NewConstraint)) { InsertViaOtherTableConstraint(AStore, NewConstraint, ACurrentTable, AStore.GetTable(OtherLinkConstraint.strOtherTable), ATemplate, ASnippet); } } } } } }
/// <summary> /// insert the viaothertable functions for one specific constraint /// </summary> /// <param name="AStore"></param> /// <param name="AConstraint"></param> /// <param name="ACurrentTable"></param> /// <param name="AOtherTable"></param> /// <param name="ATemplate"></param> /// <param name="ASnippet"></param> private static void InsertViaOtherTableConstraint(TDataDefinitionStore AStore, TConstraint AConstraint, TTable ACurrentTable, TTable AOtherTable, ProcessTemplate ATemplate, ProcessTemplate ASnippet) { ATemplate.AddToCodelet("USINGNAMESPACES", GetNamespace(AOtherTable.strGroup), false); ProcessTemplate snippetViaTable = ATemplate.GetSnippet("VIAOTHERTABLE"); snippetViaTable.SetCodelet("OTHERTABLENAME", TTable.NiceTableName(AOtherTable.strName)); snippetViaTable.SetCodelet("SQLOTHERTABLENAME", AOtherTable.strName); string ProcedureName = "Via" + TTable.NiceTableName(AOtherTable.strName); // check if other foreign key exists that references the same table, e.g. // PBankAccess.CountViaPPartnerPartnerKey // PBankAccess.CountViaPPartnerContactPartnerKey string DifferentField = FindOtherConstraintSameOtherTable(ACurrentTable.grpConstraint, AConstraint); if (DifferentField.Length != 0) { ProcedureName += TTable.NiceFieldName(DifferentField); } int notUsedInt; string formalParametersOtherPrimaryKey; string actualParametersOtherPrimaryKey; string dummy; PrepareCodeletsPrimaryKey(AOtherTable, out formalParametersOtherPrimaryKey, out actualParametersOtherPrimaryKey, out dummy, out notUsedInt); int numberFields; string namesOfThisTableFields; string notUsed; PrepareCodeletsForeignKey( AOtherTable, AConstraint, out notUsed, out notUsed, out notUsed, out numberFields, out namesOfThisTableFields); snippetViaTable.SetCodelet("VIAPROCEDURENAME", ProcedureName); snippetViaTable.SetCodelet("FORMALPARAMETERSOTHERPRIMARYKEY", formalParametersOtherPrimaryKey); snippetViaTable.SetCodelet("ACTUALPARAMETERSOTHERPRIMARYKEY", actualParametersOtherPrimaryKey); snippetViaTable.SetCodelet("NUMBERFIELDS", numberFields.ToString()); snippetViaTable.SetCodelet("NUMBERFIELDSOTHER", (actualParametersOtherPrimaryKey.Split(',').Length).ToString()); snippetViaTable.SetCodelet("THISTABLEFIELDS", namesOfThisTableFields); AddDirectReference(AConstraint); ASnippet.InsertSnippet("VIAOTHERTABLE", snippetViaTable); }
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); }
/// 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 ProcessTemplate WriteRemotableClass(ProcessTemplate ATemplate, String FullNamespace, String Classname, String Namespace, Boolean HighestLevel, SortedList <string, TNamespace>children, SortedList <string, TypeDeclaration>connectors) { if ((children.Count == 0) && !HighestLevel) { return new ProcessTemplate(); } ProcessTemplate remotableClassSnippet = ATemplate.GetSnippet("REMOTABLECLASS"); remotableClassSnippet.SetCodelet("SUBNAMESPACEREMOTABLECLASSES", string.Empty); remotableClassSnippet.SetCodelet("NAMESPACE", Namespace); remotableClassSnippet.SetCodelet("CLIENTOBJECTFOREACHPROPERTY", string.Empty); remotableClassSnippet.SetCodelet("SUBNAMESPACEPROPERTIES", string.Empty); foreach (TNamespace sn in children.Values) { ProcessTemplate subNamespaceSnippet = ATemplate.GetSnippet("SUBNAMESPACEPROPERTY"); string NamespaceName = Namespace + sn.Name; if (HighestLevel) { NamespaceName = sn.Name; } subNamespaceSnippet.SetCodelet("OBJECTNAME", sn.Name); subNamespaceSnippet.SetCodelet("NAMESPACENAME", NamespaceName); subNamespaceSnippet.SetCodelet("NAMESPACE", Namespace); remotableClassSnippet.InsertSnippet("SUBNAMESPACEPROPERTIES", subNamespaceSnippet); if (sn.Children.Count > 0) { // properties for each sub namespace foreach (TNamespace subnamespace in sn.Children.Values) { ATemplate.InsertSnippet("SUBNAMESPACEREMOTABLECLASSES", WriteRemotableClass(ATemplate, FullNamespace + "." + sn.Name + "." + subnamespace.Name, sn.Name + subnamespace.Name, NamespaceName + subnamespace.Name, false, subnamespace.Children, connectors)); } remotableClassSnippet.InsertSnippet("CLIENTOBJECTFOREACHPROPERTY", TCreateClientRemotingClass.AddClientRemotingClass( FTemplateDir, "T" + NamespaceName + "NamespaceRemote", "I" + NamespaceName + "Namespace", new List <TypeDeclaration>(), FullNamespace + "." + sn.Name, sn.Children )); } else { remotableClassSnippet.InsertSnippet("CLIENTOBJECTFOREACHPROPERTY", TCreateClientRemotingClass.AddClientRemotingClass( FTemplateDir, "T" + NamespaceName + "NamespaceRemote", "I" + NamespaceName + "Namespace", TCollectConnectorInterfaces.FindTypesInNamespace(connectors, FullNamespace + "." + sn.Name) )); } } return remotableClassSnippet; }
/// <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); }
/// <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 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); }
static private void WriteUIConnector(string connectorname, TypeDeclaration connectorClass, ProcessTemplate Template) { List <string>MethodNames = new List <string>(); foreach (ConstructorDeclaration m in CSParser.GetConstructors(connectorClass)) { if (TCollectConnectorInterfaces.IgnoreMethod(m.Attributes, m.Modifier)) { continue; } string connectorNamespaceName = ((NamespaceDeclaration)connectorClass.Parent).Name; if (!FUsingNamespaces.ContainsKey(connectorNamespaceName)) { FUsingNamespaces.Add(connectorNamespaceName, connectorNamespaceName); } ProcessTemplate snippet = Template.GetSnippet("UICONNECTORCONSTRUCTOR"); snippet.SetCodelet("UICONNECTORCLASS", connectorClass.Name); snippet.SetCodelet("CHECKUSERMODULEPERMISSIONS", "// TODO CHECKUSERMODULEPERMISSIONS"); PrepareParametersForMethod(snippet, null, m.Parameters, m.Name, ref MethodNames); Template.InsertSnippet("UICONNECTORS", snippet); } // foreach public method create a method foreach (MethodDeclaration m in CSParser.GetMethods(connectorClass)) { if (TCollectConnectorInterfaces.IgnoreMethod(m.Attributes, m.Modifier)) { continue; } ProcessTemplate snippet = Template.GetSnippet("UICONNECTORMETHOD"); snippet.SetCodelet("METHODNAME", m.Name); snippet.SetCodelet("UICONNECTORCLASS", connectorClass.Name); snippet.SetCodelet("CHECKUSERMODULEPERMISSIONS", "// TODO CHECKUSERMODULEPERMISSIONS"); PrepareParametersForMethod(snippet, m.TypeReference, m.Parameters, m.Name, ref MethodNames); if (snippet.FCodelets["PARAMETERDEFINITION"].Length > 0) { snippet.AddToCodeletPrepend("PARAMETERDEFINITION", ", "); } Template.InsertSnippet("UICONNECTORS", snippet); } // foreach public property create a method foreach (PropertyDeclaration p in CSParser.GetProperties(connectorClass)) { if (TCollectConnectorInterfaces.IgnoreMethod(p.Attributes, p.Modifier)) { continue; } string propertytype = p.TypeReference.ToString(); // check if the parametertype is not a generic type, eg. dictionary or list if (!propertytype.Contains("<")) { propertytype = propertytype == "string" || propertytype == "String" ? "System.String" : propertytype; propertytype = propertytype == "bool" || propertytype == "Boolean" ? "System.Boolean" : propertytype; if (propertytype.Contains("UINT") || propertytype.Contains("unsigned")) { propertytype = propertytype.Contains("UInt32") || propertytype == "unsigned int" ? "System.UInt32" : propertytype; propertytype = propertytype.Contains("UInt16") || propertytype == "unsigned short" ? "System.UInt16" : propertytype; propertytype = propertytype.Contains("UInt64") || propertytype == "unsigned long" ? "System.UInt64" : propertytype; } else { propertytype = propertytype.Contains("Int32") || propertytype == "int" ? "System.Int32" : propertytype; propertytype = propertytype.Contains("Int16") || propertytype == "short" ? "System.Int16" : propertytype; propertytype = propertytype.Contains("Int64") || propertytype == "long" ? "System.Int64" : propertytype; } propertytype = propertytype.Contains("Decimal") || propertytype == "decimal" ? "System.Decimal" : propertytype; } bool BinaryReturn = !((propertytype == "System.Int64") || (propertytype == "System.Int32") || (propertytype == "System.Int16") || (propertytype == "System.String") || (propertytype == "System.Boolean")); string EncodedType = propertytype; string EncodeReturnType = string.Empty; string ActualValue = "AValue"; if (BinaryReturn) { EncodedType = "System.String"; EncodeReturnType = "THttpBinarySerializer.SerializeObject"; ActualValue = "(" + propertytype + ")THttpBinarySerializer.DeserializeObject(AValue)"; } ProcessTemplate propertySnippet = Template.GetSnippet("UICONNECTORPROPERTY"); propertySnippet.SetCodelet("UICONNECTORCLASS", connectorClass.Name); propertySnippet.SetCodelet("ENCODEDTYPE", EncodedType); propertySnippet.SetCodelet("PROPERTYNAME", p.Name); if (p.HasGetRegion) { if (p.TypeReference.ToString().StartsWith("I")) { if (p.TypeReference.ToString() == "IAsynchronousExecutionProgress") { FContainsAsynchronousExecutionProgress = true; } // return the ObjectID of the Sub-UIConnector propertySnippet.InsertSnippet("GETTER", Template.GetSnippet("GETSUBUICONNECTOR")); propertySnippet.SetCodelet("ENCODEDTYPE", "System.String"); } else { propertySnippet.SetCodelet("GETTER", "return {#ENCODERETURNTYPE}((({#UICONNECTORCLASS})FUIConnectors[ObjectID]).{#PROPERTYNAME});"); propertySnippet.SetCodelet("ENCODERETURNTYPE", EncodeReturnType); } } if (p.HasSetRegion) { propertySnippet.SetCodelet("SETTER", "true"); propertySnippet.SetCodelet("ACTUALPARAMETERS", ActualValue); } Template.InsertSnippet("UICONNECTORS", propertySnippet); } }
/// <summary> /// main function for creating a control /// </summary> /// <param name="ACtrl"></param> /// <param name="ATemplate"></param> /// <param name="AItemsPlaceholder"></param> /// <param name="ANodeName"></param> /// <param name="AWriter"></param> public static void InsertControl(TControlDef ACtrl, ProcessTemplate ATemplate, string AItemsPlaceholder, string ANodeName, TFormWriter AWriter) { XmlNode controlsNode = TXMLParser.GetChild(ACtrl.xmlNode, ANodeName); List <XmlNode>childNodes = TYml2Xml.GetChildren(controlsNode, true); if ((childNodes.Count > 0) && childNodes[0].Name.StartsWith("Row")) { foreach (XmlNode row in TYml2Xml.GetChildren(controlsNode, true)) { ProcessTemplate snippetRowDefinition = AWriter.FTemplate.GetSnippet("ROWDEFINITION"); StringCollection children = TYml2Xml.GetElements(controlsNode, row.Name); foreach (string child in children) { TControlDef childCtrl = AWriter.FCodeStorage.FindOrCreateControl(child, ACtrl.controlName); IControlGenerator ctrlGen = AWriter.FindControlGenerator(childCtrl); ProcessTemplate ctrlSnippet = ctrlGen.SetControlProperties(AWriter, childCtrl); ProcessTemplate snippetCellDefinition = AWriter.FTemplate.GetSnippet("CELLDEFINITION"); LayoutCellInForm(childCtrl, children.Count, ctrlSnippet, snippetCellDefinition); if ((children.Count == 1) && ctrlGen is RadioGroupSimpleGenerator) { // do not use the ROWDEFINITION, but insert control directly // this helps with aligning the label for the group radio buttons snippetRowDefinition.InsertSnippet("ITEMS", ctrlSnippet, ","); } else { snippetCellDefinition.InsertSnippet("ITEM", ctrlSnippet); snippetRowDefinition.InsertSnippet("ITEMS", snippetCellDefinition, ","); } } ATemplate.InsertSnippet(AItemsPlaceholder, snippetRowDefinition, ","); } } else { foreach (XmlNode childNode in childNodes) { string child = TYml2Xml.GetElementName(childNode); TControlDef childCtrl = AWriter.FCodeStorage.FindOrCreateControl(child, ACtrl.controlName); if ((ANodeName != "HiddenValues") && (childCtrl.controlTypePrefix == "hid")) { // somehow, hidden values get into the controls list as well. we don't want them there continue; } IControlGenerator ctrlGen = AWriter.FindControlGenerator(childCtrl); if (ctrlGen is FieldSetGenerator) { InsertControl(AWriter.FCodeStorage.FindOrCreateControl(child, ACtrl.controlName), ATemplate, AItemsPlaceholder, ANodeName, AWriter); } else { ProcessTemplate ctrlSnippet = ctrlGen.SetControlProperties(AWriter, childCtrl); ProcessTemplate snippetCellDefinition = AWriter.FTemplate.GetSnippet("CELLDEFINITION"); LayoutCellInForm(childCtrl, -1, ctrlSnippet, snippetCellDefinition); ATemplate.InsertSnippet(AItemsPlaceholder, ctrlSnippet, ","); } } } }
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> /// insert the buttons for the form, eg. submit button, cancel button, etc /// </summary> /// <param name="ACtrl"></param> /// <param name="ATemplate"></param> /// <param name="AItemsPlaceholder"></param> /// <param name="AWriter"></param> public static void InsertButtons(TControlDef ACtrl, ProcessTemplate ATemplate, string AItemsPlaceholder, TFormWriter AWriter) { StringCollection children = TYml2Xml.GetElements(ACtrl.xmlNode, "Buttons"); foreach (string child in children) { TControlDef childCtrl = AWriter.FCodeStorage.FindOrCreateControl(child, ACtrl.controlName); IControlGenerator ctrlGen = AWriter.FindControlGenerator(childCtrl); ProcessTemplate ctrlSnippet = ctrlGen.SetControlProperties(AWriter, childCtrl); ProcessTemplate snippetCellDefinition = AWriter.FTemplate.GetSnippet("CELLDEFINITION"); LayoutCellInForm(childCtrl, -1, ctrlSnippet, snippetCellDefinition); ATemplate.InsertSnippet(AItemsPlaceholder, ctrlSnippet, ","); } }
/// <summary> /// get the specified snippet, in a new Template /// </summary> /// <param name="ASnippetName"></param> /// <returns></returns> public ProcessTemplate GetSnippet(string ASnippetName) { ProcessTemplate snippetTemplate = new ProcessTemplate(); if (FSnippets.ContainsKey(ASnippetName)) { snippetTemplate.FTemplateCode = new StringBuilder(FSnippets[ASnippetName]); } else { snippetTemplate.FTemplateCode = null; } if (snippetTemplate.FTemplateCode == null) { throw new Exception("Cannot find snippet with name " + ASnippetName); } snippetTemplate.FSnippets = this.FSnippets; return snippetTemplate; }
/// 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)); }
/// <summary> /// insert the snippet into the current template, into the given codelet. /// use separator to separate from previous items inserted into that codelet /// </summary> /// <param name="ACodeletName"></param> /// <param name="ASnippet"></param> /// <param name="ASeparator"></param> public void InsertSnippet(string ACodeletName, ProcessTemplate ASnippet, string ASeparator) { ASnippet.ReplaceCodelets(); ASnippet.ProcessIFDEFs(ref ASnippet.FTemplateCode); ASnippet.ProcessIFNDEFs(ref ASnippet.FTemplateCode); if (FCodelets.ContainsKey(ACodeletName) && (FCodelets[ACodeletName].Length > 0)) { AddSeparatorToCodelet(ACodeletName, ASeparator); } AddToCodelet(ACodeletName, ASnippet.FTemplateCode.ToString()); }
/// <summary> /// constructor, open template from file /// </summary> /// <param name="AFullPath"></param> public ProcessTemplate(string AFullPath = null) { if ((AFullPath == null) || (AFullPath.Length == 0)) { return; } if (!File.Exists(AFullPath)) { throw new Exception("Cannot find template file " + AFullPath + "; please adjust the TemplateDir parameter"); } StreamReader r; r = File.OpenText(AFullPath); FTemplateCode = new StringBuilder(); while (!r.EndOfStream) { string line = r.ReadLine().TrimEnd(new char[] { '\r', '\t', ' ', '\n' }).Replace("\t", " "); FTemplateCode.Append(line).Append(Environment.NewLine); } r.Close(); // add other files, {#INCLUDE <filename>} while (FTemplateCode.Contains("{#INCLUDE ")) { Int32 pos = FTemplateCode.IndexOf("{#INCLUDE "); Int32 newLinePos = FTemplateCode.IndexOf(Environment.NewLine, pos); string line = FTemplateCode.Substring(pos, newLinePos - pos); Int32 bracketClosePos = FTemplateCode.IndexOf("}", pos); string filename = FTemplateCode.Substring(pos + "{#INCLUDE ".Length, bracketClosePos - pos - "{#INCLUDE ".Length).Trim(); // do this recursively, to get snippets and code in the right place, even from the include files ProcessTemplate includedTemplate = new ProcessTemplate(Path.GetDirectoryName(AFullPath) + Path.DirectorySeparatorChar + filename); FTemplateCode = FTemplateCode.Replace(line, includedTemplate.FTemplateCode.ToString()); foreach (string key in includedTemplate.FSnippets.Keys) { FSnippets.Add(key, includedTemplate.FSnippets[key]); } } // split off snippets (identified by "{##") if (FTemplateCode.Contains("{##")) { StringCollection snippets = StringHelper.StrSplit(FTemplateCode.ToString(), "{##"); // first part is the actual template code FTemplateCode = new StringBuilder(snippets[0]); for (int counter = 1; counter < snippets.Count; counter++) { string snippetName = snippets[counter].Substring(0, snippets[counter].IndexOf("}")); // exclude first newline string snippetText = snippets[counter].Substring(snippets[counter].IndexOf(Environment.NewLine) + Environment.NewLine.Length); // remove all whitespaces from the end, but keep one line ending for ENDIF etc snippetText = snippetText.TrimEnd(new char[] { '\n', '\r', ' ', '\t' }) + Environment.NewLine; FSnippets.Add(snippetName, snippetText); } } // just make sure that there is a newline at the end, for ENDIF etc FTemplateCode.Append(Environment.NewLine); }
/// <summary> /// Creates a HTML file that contains central documentation of the Error Codes that are used throughout OpenPetra code /// </summary> public static bool Execute(string ACSharpPath, string ATemplateFilePath, string AOutFilePath) { Dictionary <string, ErrCodeInfo>ErrorCodes = new Dictionary <string, ErrCodeInfo>(); CSParser parsedFile = new CSParser(ACSharpPath + "/ICT/Common/ErrorCodes.cs"); string ErrCodeCategoryNice = String.Empty; TLogging.Log("Creating HTML documentation of OpenPetra Error Codes..."); ProcessFile(parsedFile, ref ErrorCodes); parsedFile = new CSParser(ACSharpPath + "/ICT/Petra/Shared/ErrorCodes.cs"); ProcessFile(parsedFile, ref ErrorCodes); parsedFile = new CSParser(ACSharpPath + "/ICT/Common/Verification/StringChecks.cs"); ProcessFile(parsedFile, ref ErrorCodes); ProcessTemplate t = new ProcessTemplate(ATemplateFilePath); Dictionary <string, ProcessTemplate>snippets = new Dictionary <string, ProcessTemplate>(); snippets.Add("GENC", t.GetSnippet("TABLE")); snippets["GENC"].SetCodelet("TABLEDESCRIPTION", "GENERAL (<i>Ict.Common* Libraries only</i>)"); snippets.Add("GEN", t.GetSnippet("TABLE")); snippets["GEN"].SetCodelet("TABLEDESCRIPTION", "GENERAL (across the OpenPetra application)"); snippets.Add("PARTN", t.GetSnippet("TABLE")); snippets["PARTN"].SetCodelet("TABLEDESCRIPTION", "PARTNER Module"); snippets.Add("PERS", t.GetSnippet("TABLE")); snippets["PERS"].SetCodelet("TABLEDESCRIPTION", "PERSONNEL Module"); snippets.Add("FIN", t.GetSnippet("TABLE")); snippets["FIN"].SetCodelet("TABLEDESCRIPTION", "FINANCE Module"); snippets.Add("CONF", t.GetSnippet("TABLE")); snippets["CONF"].SetCodelet("TABLEDESCRIPTION", "CONFERENCE Module"); snippets.Add("FINDEV", t.GetSnippet("TABLE")); snippets["FINDEV"].SetCodelet("TABLEDESCRIPTION", "FINANCIAL DEVELOPMENT Module"); snippets.Add("SYSMAN", t.GetSnippet("TABLE")); snippets["SYSMAN"].SetCodelet("TABLEDESCRIPTION", "SYSTEM MANAGER Module"); foreach (string snippetkey in snippets.Keys) { snippets[snippetkey].SetCodelet("ABBREVIATION", snippetkey); snippets[snippetkey].SetCodelet("ROWS", string.Empty); } foreach (string code in ErrorCodes.Keys) { foreach (string snippetkey in snippets.Keys) { if (code.StartsWith(snippetkey + ".")) { ProcessTemplate row = t.GetSnippet("ROW"); row.SetCodelet("CODE", code); ErrCodeInfo ErrCode = ErrorCodes[code]; switch (ErrCode.Category) { case ErrCodeCategory.NonCriticalError: ErrCodeCategoryNice = "Non-critical Error"; break; default: ErrCodeCategoryNice = ErrCode.Category.ToString("G"); break; } row.AddToCodelet("SHORTDESCRIPTION", (ErrCode.ShortDescription)); row.AddToCodelet("FULLDESCRIPTION", (ErrCode.FullDescription)); row.AddToCodelet("ERRORCODECATEGORY", (ErrCodeCategoryNice)); row.AddToCodelet("DECLARINGCLASS", (ErrCode.ErrorCodeConstantClass)); snippets[snippetkey].InsertSnippet("ROWS", row); } } } foreach (string snippetkey in snippets.Keys) { t.InsertSnippet("TABLES", snippets[snippetkey]); } return t.FinishWriting(AOutFilePath, ".html", true); }