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);
}
