public override List <CodeNamespaceImport> GenerateImports(Activity activity) { return(new List <CodeNamespaceImport> { new CodeNamespaceImport(TargetAppNameSpaceService.domainContractNamespaceName()) }); }
public override List <System.CodeDom.CodeNamespaceImport> GenerateImports(Activity activity) { return(new List <CodeNamespaceImport> { new CodeNamespaceImport(TargetAppNameSpaceService.EventSourcingNameSpace()), }); }
public override List <CodeNamespaceImport> GenerateImports(Activity activity) { return(new List <CodeNamespaceImport> { new CodeNamespaceImport(TargetAppNameSpaceService.EngineCommandNamespace()) }); }
private CodeNamespaceCollection GenerateProcessVariablesNamespaces(TibcoBWProcess tibcoBwProcessToGenerate) { var processVariableNameNamespaces = new CodeNamespaceCollection(); if (tibcoBwProcessToGenerate.ProcessVariables != null) { foreach (var item in tibcoBwProcessToGenerate.ProcessVariables) { if (!CodeDomUtils.IsBasicType(item.Parameter.Type)) { try { processVariableNameNamespaces.Add( this.xsdClassGenerator.Build(item.ObjectXNodes, TargetAppNameSpaceService.myAppName() + "." + tibcoBwProcessToGenerate.VariablesNameSpace)); } catch (Exception e) { Log.Error( "unable to generate Process Variable object class for this process: " + tibcoBwProcessToGenerate.ProcessName, e); } } } } return(processVariableNameNamespaces); }
public List <CodeNamespaceImport> GenerateImports(Activity activity) { return(new List <CodeNamespaceImport> { new CodeNamespaceImport(TargetAppNameSpaceService.EventSourcingNameSpace()), new CodeNamespaceImport("System.Threading") }); }
public override List <CodeNamespaceImport> GenerateImports(Activity activity) { return(new List <CodeNamespaceImport> { new CodeNamespaceImport(TargetAppNameSpaceService.javaToolsNameSpace()), new CodeNamespaceImport(TargetAppNameSpaceService.javaToolsNameSpace()) }); }
public void Should_Convert_XsdImport_in_Code_namespace_to_import_when_no_slash() { // Arrange var expected = ".Process.DAI.PNO.Common"; // Act var import = TargetAppNameSpaceService.ConvertXsdImportToNameSpace(".Process.DAI.PNO.Common"); // Assert Assert.AreEqual(expected, import); }
public void Should_Convert_Unix_XsdImport_in_Code_namespace_to_import() { // Arrange var expected = "DAI.PNO.XSD"; // Act var import = TargetAppNameSpaceService.ConvertXsdImportToNameSpace("/XmlSchemas/DAI/PNO/XSD/RM3D.xsd"); // Assert Assert.AreEqual(expected, import); }
private CodeNamespace GenerateTimerSubscriberImplementation() { var timerSubscriberNamespace = new CodeNamespace(); timerSubscriberNamespace.Name = TargetAppNameSpaceService.EventSourcingNameSpace(); timerSubscriberNamespace.Imports.Add(new CodeNamespaceImport("System")); var timerSubscriberClass = new CodeTypeDeclaration("TimerSubscriber"); timerSubscriberClass.IsClass = true; timerSubscriberClass.Attributes = MemberAttributes.Public; timerSubscriberClass.BaseTypes.Add(SubscriberInterfaceBuilder.InterfaceSubscriberName); var event1 = new CodeMemberEvent(); // Sets a name for the event. event1.Name = "ResponseReceived"; event1.Attributes = MemberAttributes.Public; // Sets the type of event. event1.Type = new CodeTypeReference("EventHandler"); timerSubscriberClass.Members.Add(event1); timerSubscriberClass.Members.Add( CodeDomUtils.GeneratePropertyWithoutSetter("WaitingTimeLimit", CSharpTypeConstant.SystemInt32)); timerSubscriberClass.Members.Add( CodeDomUtils.GeneratePropertyWithoutSetter("IsStarted", CSharpTypeConstant.SystemBoolean)); timerSubscriberClass.Members.Add( new CodeMemberMethod { Name = "Start", ReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid), Attributes = MemberAttributes.Public }); timerSubscriberClass.Members.Add( new CodeMemberMethod { Name = "Stop", ReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid), Attributes = MemberAttributes.Public }); timerSubscriberClass.Members.Add( new CodeMemberMethod { Name = "Confirm", ReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid), Attributes = MemberAttributes.Public }); timerSubscriberNamespace.Types.Add(timerSubscriberClass); return(timerSubscriberNamespace); }
public override List <CodeNamespaceImport> GenerateImports(Activity activity) { var import4Activities = new List <CodeNamespaceImport>(); var callProcessActivity = (CallProcessActivity)activity; import4Activities.Add(new CodeNamespaceImport(TargetAppNameSpaceService.myAppName() + "." + TargetAppNameSpaceService.RemoveFirstDot(callProcessActivity.TibcoProcessToCall.ShortNameSpace))); if (IsTheProcessInputRequiresAnImport(callProcessActivity)) { import4Activities.Add(new CodeNamespaceImport(TargetAppNameSpaceService.myAppName() + "." + TargetAppNameSpaceService.RemoveFirstDot(callProcessActivity.TibcoProcessToCall.InputAndOutputNameSpace))); } return(import4Activities); }
public void Should_Convert_Windows_pathname_in_Code_namespace_to_import() { // Arrange var expected = "DAI.PNO.XSD"; ConfigurationApp.SaveProperty(MainClass.ProjectDirectory, "c:\\test"); // Act var import = TargetAppNameSpaceService.ConvertXsdImportToNameSpace("c:\\test\\XmlSchemas\\DAI\\PNO\\XSD\\RM3D.xsd"); // Assert Assert.AreEqual(expected, import); }
public CodeNamespaceCollection Build() { var TibcoXslHelperNameSpace = new CodeNamespace(TargetAppNameSpaceService.xmlToolsNameSpace()); // Generate the Service TibcoXslHelperNameSpace.Imports.AddRange(this.GenerateImports()); var TibcoXslHelperClass = this.GenerateClass(); TibcoXslHelperNameSpace.Types.Add(TibcoXslHelperClass); return(new CodeNamespaceCollection { TibcoXslHelperNameSpace }); }
public CodeNamespace Build() { var namespaceResult = new CodeNamespace(TargetAppNameSpaceService.loggerNameSpace()); namespaceResult.Imports.Add(new CodeNamespaceImport("System")); var dataAccessInterface = new CodeTypeDeclaration(); dataAccessInterface.Name = "ILogger"; dataAccessInterface.IsInterface = true; var message = new CodeParameterDeclarationExpression("System.String", "message"); var parameters = new CodeParameterDeclarationExpressionCollection(); parameters.Add(message); var voidReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid); var debugMethod = new CodeMemberMethod { Name = "Debug", ReturnType = voidReturnType }; debugMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(debugMethod); var infoMethod = new CodeMemberMethod { Name = "Info", ReturnType = voidReturnType }; infoMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(infoMethod); var errorMethod = new CodeMemberMethod { Name = "Error", ReturnType = voidReturnType }; errorMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(errorMethod); var warnMethod = new CodeMemberMethod { Name = "Warning", ReturnType = voidReturnType }; warnMethod.Parameters.AddRange(parameters); dataAccessInterface.Members.Add(warnMethod); namespaceResult.Types.Add(dataAccessInterface); return(namespaceResult); }
public CodeNamespace GenerateProcessInterface(TibcoBWProcess tibcoBwProcessToGenerate, CodeTypeDeclaration tibcoBwProcessClassModel) { var namespaceName = TargetAppNameSpaceService.myAppName() + "." + tibcoBwProcessToGenerate.ShortNameSpace; var interfaceNameSpace = InterfaceExtractorFromClass.Extract(tibcoBwProcessClassModel, TargetAppNameSpaceService.myAppName() + "." + tibcoBwProcessToGenerate.ShortNameSpace); if ((tibcoBwProcessToGenerate.StartActivity != null && tibcoBwProcessToGenerate.StartActivity.Parameters != null) || (tibcoBwProcessToGenerate.EndActivity != null && tibcoBwProcessToGenerate.EndActivity.Parameters != null)) { interfaceNameSpace.Imports.Add(new CodeNamespaceImport(TargetAppNameSpaceService.myAppName() + "." + tibcoBwProcessToGenerate.InputAndOutputNameSpace)); } interfaceNameSpace.Imports.AddRange(this.GenerateXsdImports(tibcoBwProcessToGenerate).ToArray()); ModuleBuilder.AddServiceToRegister(namespaceName + "." + interfaceNameSpace.Types[0].Name, namespaceName + "." + tibcoBwProcessClassModel.Name); return(interfaceNameSpace); }
public CodeNamespace Build() { var namespaceResult = new CodeNamespace(TargetAppNameSpaceService.dataAccessCommonNamespace()); this.GenerateImports(namespaceResult); var dataAccessInterface = this.GenerateDataAccessInterface(); namespaceResult.Types.Add(dataAccessInterface); var dataAccessFactoryInterface = this.GenerateDataAccessFactoryInterface(); namespaceResult.Types.Add(dataAccessFactoryInterface); return(namespaceResult); }
public CodeNamespaceImport[] GenerateServiceImport(JdbcQueryActivity jdbcQueryActivity) { var imports = new List <CodeNamespaceImport> { new CodeNamespaceImport("System"), new CodeNamespaceImport(TargetAppNameSpaceService.domainContractNamespaceName()), new CodeNamespaceImport(TargetAppNameSpaceService.dataAccessNamespace()) }; if (jdbcQueryActivity.QueryOutputStatementParameters != null) { imports.Add(new CodeNamespaceImport("System.Collections.Generic")); } return(imports.ToArray()); }
public override List <CodeNamespaceImport> GenerateImports(Activity activity) { var jdbcQueryActivity = (JdbcQueryActivity)activity; var imports = new List <CodeNamespaceImport> { new CodeNamespaceImport(TargetAppNameSpaceService.domainContractNamespaceName()) }; if (jdbcQueryActivity.QueryOutputStatementParameters != null) { imports.Add(new CodeNamespaceImport("System.Collections.Generic")); } return(imports); }
private List <CodeNamespaceImport> GenerateXsdImports(TibcoBWProcess tibcoBwProcessToGenerate) { var imports = new List <CodeNamespaceImport>(); if (tibcoBwProcessToGenerate.XsdImports != null) { foreach (var xsdImport in tibcoBwProcessToGenerate.XsdImports) { imports.Add( new CodeNamespaceImport( TargetAppNameSpaceService.myAppName() + "." + TargetAppNameSpaceService.ConvertXsdImportToNameSpace(xsdImport.SchemaLocation))); } } return(imports); }
private CodeNamespaceImport[] GenerateImports() { var imports = new List <CodeNamespaceImport> { new CodeNamespaceImport("System"), new CodeNamespaceImport(TargetAppNameSpaceService.domainContractNamespaceName()), new CodeNamespaceImport(TargetAppNameSpaceService.dataAccessNamespace()), new CodeNamespaceImport(TargetAppNameSpaceService.domainServiceNamespaceName()), new CodeNamespaceImport(TargetAppNameSpaceService.EngineCommandNamespace()), new CodeNamespaceImport(TargetAppNameSpaceService.dataAccessNamespace()), new CodeNamespaceImport(TargetAppNameSpaceService.EventSourcingNameSpace()), new CodeNamespaceImport(TargetAppNameSpaceService.loggerNameSpace()), new CodeNamespaceImport(TargetAppNameSpaceService.xmlToolsNameSpace()) }; return(imports.ToArray()); }
public CodeNamespaceCollection Build() { var sharedVariableServiceNameSpace = new CodeNamespace(TargetAppNameSpaceService.sharedVariableNameSpace()); // Generate the Service sharedVariableServiceNameSpace.Imports.AddRange(this.GenerateImports()); var sharedVariableService = this.GenerateClass(); sharedVariableServiceNameSpace.Types.Add(sharedVariableService); // Generate the corresponding interface var sharedVariableServiceInterfaceNameSpace = InterfaceExtractorFromClass.Extract(sharedVariableService, TargetAppNameSpaceService.sharedVariableNameSpace()); return(new CodeNamespaceCollection { sharedVariableServiceNameSpace, sharedVariableServiceInterfaceNameSpace }); }
public CodeNamespaceCollection Build() { var xmlParserHelperNameSpace = new CodeNamespace(TargetAppNameSpaceService.xmlToolsNameSpace()); // Generate the Service xmlParserHelperNameSpace.Imports.AddRange(this.GenerateImports()); var xmlParserHelperService = this.GenerateClass(); xmlParserHelperNameSpace.Types.Add(xmlParserHelperService); // Generate the corresponding interface var xmlParserHelperServiceInterfaceNameSpace = InterfaceExtractorFromClass.Extract(xmlParserHelperService, TargetAppNameSpaceService.xmlToolsNameSpace()); ModuleBuilder.AddServiceToRegister(IXmlParserHelperServiceName, XmlParserHelperServiceName); return(new CodeNamespaceCollection { xmlParserHelperNameSpace, xmlParserHelperServiceInterfaceNameSpace }); }
private CodeNamespace GenerateSubscriberInterface() { var subscriberInterfaceNamespace = new CodeNamespace(); subscriberInterfaceNamespace.Name = TargetAppNameSpaceService.EventSourcingNameSpace(); subscriberInterfaceNamespace.Imports.Add(new CodeNamespaceImport("System")); var subscriberInterfaceClass = new CodeTypeDeclaration(InterfaceSubscriberName); subscriberInterfaceClass.IsInterface = true; subscriberInterfaceClass.Members.Add( CodeDomUtils.GeneratePropertyWithoutSetterForInterface("WaitingTimeLimit", CSharpTypeConstant.SystemInt32)); subscriberInterfaceClass.Members.Add( CodeDomUtils.GeneratePropertyWithoutSetterForInterface("IsStarted", CSharpTypeConstant.SystemBoolean)); var snippet = new CodeSnippetTypeMember(); snippet.Text = " event EventHandler ResponseReceived;"; subscriberInterfaceClass.Members.Add(snippet); subscriberInterfaceClass.Members.Add( new CodeMemberMethod { Name = "Start", ReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid) }); subscriberInterfaceClass.Members.Add( new CodeMemberMethod { Name = "Stop", ReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid) }); subscriberInterfaceClass.Members.Add( new CodeMemberMethod { Name = "Confirm", ReturnType = new CodeTypeReference(CSharpTypeConstant.SystemVoid) }); subscriberInterfaceNamespace.Types.Add(subscriberInterfaceClass); return(subscriberInterfaceNamespace); }
/// <summary> /// Generates the import. /// </summary> /// <returns>The import.</returns> /// <param name="tibcoBwProcessToGenerate">Tibco bw process to generate.</param> public CodeNamespaceImport[] GenerateImport(TibcoBWProcess tibcoBwProcessToGenerate) { var imports = new List <CodeNamespaceImport> { new CodeNamespaceImport("System"), new CodeNamespaceImport(TargetAppNameSpaceService.xmlToolsNameSpace()), new CodeNamespaceImport(TargetAppNameSpaceService.loggerNameSpace()) }; if ((tibcoBwProcessToGenerate.StartActivity != null && tibcoBwProcessToGenerate.StartActivity.Parameters != null) || (tibcoBwProcessToGenerate.EndActivity != null && tibcoBwProcessToGenerate.EndActivity.Parameters != null)) { imports.Add(new CodeNamespaceImport(TargetAppNameSpaceService.myAppName() + "." + tibcoBwProcessToGenerate.InputAndOutputNameSpace)); } imports.AddRange(this.GenerateXsdImports(tibcoBwProcessToGenerate)); return(imports.ToArray()); }
public void Should_generate_class() { var resultSetNameSpace = this.resultSetBuilder.Build(this.jdbcQueryActivity); var generatedCode = TestCodeGeneratorUtils.GenerateCode(resultSetNameSpace); Assert.AreEqual(@"namespace " + TargetAppNameSpaceService.domainContractNamespaceName() + @" { using System; public class Currency { public System.String FirstOutput { get; set; } public System.String SecondOutput { get; set; } } } ", generatedCode); }
public CodeNamespace Build(string dataBaseAttributeName) { var dataBaseAttributeNameSpace = new CodeNamespace(TargetAppNameSpaceService.dataAccessCommonNamespace()); dataBaseAttributeNameSpace.Imports.Add(new CodeNamespaceImport("System")); var dataAccessToGenerate = new CodeTypeDeclaration(); dataAccessToGenerate.IsClass = true; dataAccessToGenerate.TypeAttributes = TypeAttributes.Public; dataAccessToGenerate.Name = dataBaseAttributeName + "Attribute"; dataAccessToGenerate.BaseTypes.Add(new CodeTypeReference("System.Attribute")); dataBaseAttributeNameSpace.Types.Add(dataAccessToGenerate); return(dataBaseAttributeNameSpace); }
public CodeNamespace Build(JdbcQueryActivity jdbcQueryActivity) { var resultSetNameSpace = new CodeNamespace(TargetAppNameSpaceService.domainContractNamespaceName()); resultSetNameSpace.Imports.AddRange(this.GenerateImport(jdbcQueryActivity)); var resultSetClass = new CodeTypeDeclaration { IsClass = true, TypeAttributes = TypeAttributes.Public, Name = VariableHelper.ToClassName(jdbcQueryActivity.ClassName) }; resultSetClass.Members.AddRange(this.GenererateProperties(jdbcQueryActivity)); resultSetNameSpace.Types.Add(resultSetClass); return(resultSetNameSpace); }
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables) { var activityMethod = base.GenerateMethods(activity, variables); var callProcessActivity = (CallProcessActivity)activity; var invocationCodeCollection = new CodeStatementCollection(); // Add the mapping if (IsTheProcessInputRequiresAnImport(callProcessActivity)) { invocationCodeCollection.AddRange( this.xslBuilder.Build( TargetAppNameSpaceService.myAppName() + "." + callProcessActivity.TibcoProcessToCall.InputAndOutputNameSpace, callProcessActivity.InputBindings)); } else { invocationCodeCollection.AddRange( this.xslBuilder.Build(callProcessActivity.InputBindings)); } // Add the invocation var processToCallReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName(callProcessActivity.TibcoProcessToCall.ProcessName)); var parameters = GenerateParameters(callProcessActivity); var methodInvocation = new CodeMethodInvokeExpression(processToCallReference, GetCalledProcess(activity).StartActivity.Name, parameters); if (this.GetReturnType(activity) == CSharpTypeConstant.SystemVoid) { invocationCodeCollection.Add(methodInvocation); } else { var code = new CodeMethodReturnStatement(methodInvocation); invocationCodeCollection.Add(code); } activityMethod[0].Statements.AddRange(invocationCodeCollection); return(activityMethod); }
public CodeNamespaceCollection Build() { var engineCommandNamespace = new CodeNamespace(TargetAppNameSpaceService.EngineCommandNamespace()); // Generate the Service engineCommandNamespace.Imports.AddRange(this.GenerateImports()); var engineCommandServiceClass = this.GenerateClass(); engineCommandNamespace.Types.Add(engineCommandServiceClass); // Generate the corresponding interface var engineCommandInterface = InterfaceExtractorFromClass.Extract(engineCommandServiceClass, TargetAppNameSpaceService.EngineCommandNamespace()); engineCommandInterface.Types.AddRange(this.GenerateReturnOutputClasses()); ModuleBuilder.AddServiceToRegister(IEngineCommandServiceName, EngineCommandServiceName); return(new CodeNamespaceCollection { engineCommandNamespace, engineCommandInterface }); }
// TODO : refacto to split the 2 generation method in 2 sub-service public CodeNamespace Build(string fileName) { var xsdCodeNamespace = new CodeNamespace(); var convertXsdImportToNameSpace = TargetAppNameSpaceService.myAppName() + "." + TargetAppNameSpaceService.ConvertXsdImportToNameSpace(fileName); try { var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read); xsdCodeNamespace = this.GeneratedClassFromStream(stream, convertXsdImportToNameSpace); } catch (Exception e) { Log.Warn("Switching mode to generate class from XSD file because it contains custom element:" + fileName); XElement allFileElement = XElement.Load(fileName); xsdCodeNamespace = this.Build(this.Parse(allFileElement, convertXsdImportToNameSpace), convertXsdImportToNameSpace); } return(xsdCodeNamespace); }
public CodeNamespace GeneratePublisherInterface() { var publisherInterfaceNamespace = new CodeNamespace { Name = TargetAppNameSpaceService.EventSourcingNameSpace() }; publisherInterfaceNamespace.Imports.Add(new CodeNamespaceImport("System")); var publisherInterfaceClass = new CodeTypeDeclaration(InterfaceSubscriberName) { IsInterface = true }; var sendMethod = this.GenerateSendMethod(); publisherInterfaceClass.Members.Add(sendMethod); publisherInterfaceNamespace.Types.Add(publisherInterfaceClass); return(publisherInterfaceNamespace); }