public override void save(string directory, string javaClass, CodeExtension codeExtension)
{
this.CopyNodes(directory, codeExtension.GetAllUsedNodes());
this.CopyLibs(directory);
this.CopyJavaFile(directory, javaClass, codeExtension);
//TODO create text:
string readMeText =
"Please do the following steps to use " + codeExtension.ClassName + ":\n" +
" 1: Add the Classes in the folders to your IDE. \n" +
" 2: Add the Libs in the 'libs' folder to your IDE and include it to the Project.\n" +
" 3: Include the permissions below to your Manifest.\n" +
" 4: Create a new " + codeExtension.ClassName + " in your code.\n" +
" 5: Populate all Setters in the class according to what they need to be set.\n" +
" 6: Call .start(); on " + codeExtension.ClassName + " to start it.\n" +
"\n\n Permission Needed:\n" +
codeExtension.GetExtras()
.Select(e => e as NeedsPermission)
.NonNull()
.Select(p => p.Permission)
.StringJoin("\n")
;
File.WriteAllText(Path.Combine(directory, "README.txt"), readMeText);
}
public override void CreateCode(Node node, CodeExtension codeExtension)
{
DataSourceNodeClass nodeClass = node.Class as DataSourceNodeClass;
codeExtension.AddSensor(node as DataSource);
codeExtension.AddExtras(nodeClass.NeededExtras);
codeExtension.AddImport(nodeClass.OutputType.Name);
codeExtension.AddImport(nodeClass.MainClass);
//Add the proxy methods to the Imports:
nodeClass.ProxyProperties
.Select(p => p.PropertyType.Name)
.ForEach(codeExtension.AddImport);
//We have a special case: Only a DataSource:
if (codeExtension.RootNode == node)
{
string code = " private void transform0(){\n"
+ " data = sensor0." + nodeClass.DataMethod + "();\n"
+ " }\n";
codeExtension.AddCodeStep(code);
}
}
private static string GenerateCode(string platform, string business, string uniqueKey, object extensions)
{
string codeKey = $"{platform}:APP:SMSVerification:{business}:{uniqueKey}";
string codeCacheString = RedisHelper.StringGet(Constant.REDIS_SMS_DBINDEX, codeKey);
string code;
if (!string.IsNullOrEmpty(codeCacheString))
{
CodeExtension <object> ext = JsonConvert.DeserializeObject <CodeExtension <object> >(codeCacheString);
code = ext?.Code ?? RandomAlphaNumericGenerator.GenerateAllNumber(6);
}
else
{
code = RandomAlphaNumericGenerator.GenerateAllNumber(6);
}
CodeExtension <object> codeCache = new CodeExtension <object>
{
Code = code,
Extension = extensions
};
RedisHelper.Set(codeKey, codeCache, TimeSpan.FromMinutes(Constant.SMS_EXPIRED_TIME));
return(code);
}
/// <summary>
/// Creates the Java source-Code for this element and stores it in the CodeExtension.
/// </summary>
/// <param name="node">To Generate for</param>
/// <param name="codeExtension">To store in</param>
public void CreateCode(Node node, CodeExtension codeExtension)
{
loaders
.ExecuteOnFirst(
e => e.Key == node.Class.NodeType,
l => l.Value.CreateCode(node, codeExtension)
);
}
public override void save(string directory, string javaClass, CodeExtension codeExtension)
{
//Check if we have a Android studio Folder:
string manifestPath = SearchManifest(directory);
if (manifestPath == null)
{
return;
}
//We have a manifest!
//Now navigate to the Source-Path:
DirectoryInfo eclipseProjectPath = Directory.GetParent(manifestPath);
string projectName = eclipseProjectPath.Name;
string projectPath = eclipseProjectPath.FullName;
//Add the permissions:
AddExtrasToManifest(manifestPath, codeExtension.GetExtras());
//Copy classes:
string srcDirPath = Path.Combine(projectPath, "src");
CopyJavaFile(srcDirPath, javaClass, codeExtension);
CopyNodes(srcDirPath, codeExtension.GetAllUsedNodes());
//Copy lib:
string libPath = Path.Combine(projectPath, "libs");
Directory.CreateDirectory(libPath);
CopyLibs(libPath);
//Add Lib to Eclipse File:
//Since Eclipse does not support AAR files, we need to copy them manually:
DirectoryInfo libDir = new DirectoryInfo(Path.Combine(WorkSpace.DIR, WorkSpace.LIBS_DIR));
foreach (var file in libDir.GetFiles())
{
//Extract the classes file from the AAR files:
if (file.Name.EndsWith(".aar"))
{
using (ZipArchive zip = ZipFile.Open(file.FullName, ZipArchiveMode.Read))
{
zip.Entries
.Where(e => e.Name == "classes.jar")
.ForEachTryIgnore(e => e.ExtractToFile(Path.Combine(libPath, file.Name)));
}
}
if (file.Name.EndsWith(".jar"))
{
file.CopyTo(Path.Combine(libPath, file.Name));
}
}
//TODO Add libs to project file?!? No clue where! :(
}
public override void CreateCode(Node node, CodeExtension codeExtension)
{
BufferNodeClass nodeClass = node.Class as BufferNodeClass;
codeExtension.AddImport(nodeClass.MainClass);
codeExtension.AddExtras(nodeClass.NeededExtras);
codeExtension.AddBuffer(node as BufferNode);
//Add the proxy methods to the Imports:
nodeClass.ProxyProperties
.Select(p => p.PropertyType.Name)
.ForEach(codeExtension.AddImport);
}
/// <summary>
/// This method writes the generated code into a single file.
/// </summary>
private void WriteSingleCodeFile()
{
// Some assertions to make debugging easier.
Debug.Assert(!string.IsNullOrEmpty(options.OutputLocation), "This action cannot be performed when output location is null or an empty string.");
Debug.Assert(!string.IsNullOrEmpty(options.OutputFileName), "This action cannot be performed when output file name is null or an empty string");
CodeExtension.RefineCodeWithShortName(codeCompileUnit);
CodeNamespace codeNamespace = CodeExtension.GenerateCode(codeCompileUnit);
codeNamespace.Name = options.TargetNamespace;
CodeCompileUnit tempUnit = new CodeCompileUnit();
tempUnit.Namespaces.Add(codeNamespace);
// Get the destination file name.
string fileName = CodeWriter.GetUniqueFileName(options.OutputLocation, options.OutputFileName, options.Language, options.OverwriteExistingFiles);
// Create a StreamWriter for writing to the destination file.
StreamWriter writer = new StreamWriter(fileName, false, Encoding.UTF8);
try
{
// Write out the code to the destination file.
provider.GenerateCodeFromCompileUnit(tempUnit, writer, codeGenerationOptions);
// Flush all buffers in the writer.
writer.Flush();
// Initialize generatedFileNames array to hold the one and only one
// file we just generated.
generatedCodeFileNames = new string[1];
// Finally add the file name to the generatedFileNames array.
generatedCodeFileNames[0] = fileName;
}
catch (IOException e)
{
// Wrap the IOException in a CodeWriterException with little bit
// more information.
throw new CodeWriterException(
string.Format("An error occurred while trying write to file {0}: {1}", fileName, e.Message), e);
}
finally
{
// No matter what happens, dispose the stream writer and release the unmanaged
// resources.
writer.Dispose();
}
}
/// <summary>
/// Generates the <see cref="CodeCompileUnit"/> based on the provide context.
/// </summary>
/// <param name="codeGeneratorContext">The code generator context.</param>
public CodeCompileUnit GenerateDataContractCode(ICodeGeneratorContext codeGeneratorContext)
{
CodeCompileUnit codeCompileUnit = CodeExtension.GenerateDataContractCode(codeGeneratorContext.XmlSchemas);
CodeExtension.RemoveDefaultTypes(codeCompileUnit);
codeCompileUnit.ImplementsBaijiSerialization(codeGeneratorContext);
if (codeGeneratorContext.CodeGenOptions.AddCustomRequestInterface)
{
DataContractGenerator.BuildElementName2TypeNameMapping(codeGeneratorContext);
DataContractGenerator.ImplementCustomInterface(codeGeneratorContext, codeCompileUnit);
}
if (codeGeneratorContext.CodeGenOptions.ForceElementNamespace)
{
DataContractGenerator.BuildElementName2TargetNamespaceMapping(codeGeneratorContext);
}
return(codeCompileUnit);
}
private void buildInterfaceCode(ICodeGeneratorContext codeGeneratorContext, InterfaceContract interfaceContract, out CodeTypeDeclaration codeType, out CodeNamespaceImportCollection imports)
{
IDictionary <XmlQualifiedName, string> ElementName2TypeNameMapping = codeGeneratorContext.ElementName2TypeNameMapping;
IDictionary <string, CodeTypeDeclaration> CodeTypeMap = codeGeneratorContext.CodeTypeMap;
imports = new CodeNamespaceImportCollection();
// generate service or client
CodeGeneratorMode generatorMode = codeGeneratorContext.CodeGenOptions.CodeGeneratorMode;
string interfaceName = "I" + interfaceContract.ServiceName.Replace("Interface", string.Empty);
CodeTypeDeclaration interfaceType = new CodeTypeDeclaration(interfaceName);
interfaceType.UserData.Add(Constants.GENERATED_TYPE, interfaceName);
interfaceType.IsClass = false;
interfaceType.TypeAttributes = TypeAttributes.Public;
interfaceType.IsInterface = true;
interfaceType.Comments.Clear();
// Generate service documentation
string serviceDoc = "Service interface auto-generated by SOA tool, DO NOT CHANGE!\n\n";
serviceDoc += "注意，实现该接口的服务在AntServiceStack服务容器中是以new instance per request的形式被初始化的，\n";
serviceDoc += "也就是说，容器会为每个请求创建一个新的服务实例，并在请求结束时释放(release)，而不是单个\n";
serviceDoc += "服务实例(singleton)服务所有的请求, 所以请务必不要在服务初始化（例如构造函数中）时做较重的初始化\n";
serviceDoc += "（例如初始化数据库等）动作，否则对性能有很大影响，如果有较重的初始化动作，\n";
serviceDoc += "请在服务实现中以静态方式（例如静态构造函数中)一次性完成，或者以IoC注入方式初始化，在服务容器\n";
serviceDoc += "启动时事先将依赖初始化并注册在容器中，让容器在构造服务实例时自动解析和注入依赖(也可在服务实现中手动解析依赖)，\n";
serviceDoc += "关于静态和依赖注入初始化的样例，请参考AntServiceStack提供的样例程序.\n\n";
if (!string.IsNullOrEmpty(interfaceContract.ServiceDocumentation))
{
serviceDoc += interfaceContract.ServiceDocumentation;
}
CodeDomHelper.CreateSummaryComment(interfaceType.Comments, serviceDoc);
// Import AntServiceStack.ServiceHost namespace, requried by both client and service sides
imports.Add(new CodeNamespaceImport(Constants.C_SERVICE_STACK_SERVICE_HOST_NAMESPACE));
if (generatorMode == CodeGeneratorMode.Service)
{
// Mark as AntServiceStack supported service
CodeAttributeDeclaration cServiceAttribute = new
CodeAttributeDeclaration("AntServiceInterface");
string serviceName = interfaceContract.ServiceName;
CodeAttributeArgument serviceNameArgument = new CodeAttributeArgument(new CodePrimitiveExpression(serviceName));
cServiceAttribute.Arguments.Add(serviceNameArgument);
string serviceNamespace = interfaceContract.ServiceNamespace;
CodeAttributeArgument serviceNamespaceArgument = new CodeAttributeArgument(new CodePrimitiveExpression(serviceNamespace));
cServiceAttribute.Arguments.Add(serviceNamespaceArgument);
Version ver = Assembly.GetExecutingAssembly().GetName().Version;
string version = ver.Major.ToString() + "." + ver.Minor.ToString() + "." +
ver.Build.ToString() + "." + ver.Revision.ToString();
CodeAttributeArgument codeGeneratorVersionArgument = new CodeAttributeArgument(new CodePrimitiveExpression(version));
cServiceAttribute.Arguments.Add(codeGeneratorVersionArgument);
interfaceType.CustomAttributes.Add(cServiceAttribute);
}
//CodeTypeDeclaration healthCheckRequestType = null;
//CodeTypeDeclaration healthCheckResponseType = null;
bool hasAsync = false;
foreach (Operation operation in interfaceContract.OperationsCollection)
{
var isHealthCheckOperation = false;
CodeMemberMethod method = new CodeMemberMethod();
method.Name = operation.Name;
if (operation.Name.ToLower() == HEALTH_CHECK_OPERATION_NAME.ToLower())
{
isHealthCheckOperation = true;
}
Message inMessage = operation.Input;
XmlQualifiedName inMessageElementQName = new XmlQualifiedName(inMessage.Element.ElementName, inMessage.Element.ElementNamespace);
string requestTypeName = null;
ElementName2TypeNameMapping.TryGetValue(inMessageElementQName, out requestTypeName);
Enforce.IsNotNull <string>(requestTypeName, "Fail to retrieve request type from wsdl using innput message element QName : " + inMessageElementQName);
CodeTypeReference requestTypeReference = new CodeTypeReference(requestTypeName);
CodeParameterDeclarationExpression methodParam =
new CodeParameterDeclarationExpression(requestTypeReference, "request");
methodParam.Type = requestTypeReference;
method.Parameters.Add(methodParam);
Message outMessage = operation.Output;
Enforce.IsNotNull <Message>(outMessage, "Fail to get out message in operation : " + operation.Name + ", only requst/response style operation is supported");
XmlQualifiedName outMessageElementQName = new XmlQualifiedName(outMessage.Element.ElementName, outMessage.Element.ElementNamespace);
string responseTypeName = null;
ElementName2TypeNameMapping.TryGetValue(outMessageElementQName, out responseTypeName);
Enforce.IsNotNull <string>(responseTypeName, "Fail to retrieve response type from wsdl using output message element QName : " + outMessageElementQName);
if (codeGeneratorContext.CodeGenOptions.GenerateAsyncOperations && outMessageElementQName.Name.EndsWith("AsyncResponse"))
{
method.ReturnType = new CodeTypeReference("Task<" + responseTypeName + ">");
hasAsync = true;
}
else
{
method.ReturnType = new CodeTypeReference(responseTypeName);
}
// SOA Policy enforcement : response type must extend SOA common AbstractResponseType
CodeTypeDeclaration responseType = null;
CodeTypeMap.TryGetValue(responseTypeName, out responseType);
Enforce.IsNotNull <CodeTypeDeclaration>(responseType, "Weird code generator internal error, please ask soa framework team for help.");
if (isHealthCheckOperation)
{
//healthCheckResponseType = responseType;
}
if (!CodeExtension.HasProperty(responseType, Constants.RESPONSE_STATUS_PROPERTY_NAME, Constants.RESPONSE_STATUS_TYPE_NAME))
{
throw new SOAPolicyViolationException(string.Format(" SOA Policy Violation, response type '{0}' does not include requried {1} property of type {2}",
responseTypeName, Constants.RESPONSE_STATUS_PROPERTY_NAME, Constants.RESPONSE_STATUS_TYPE_NAME));
}
CodeTypeDeclaration responseStatusType = null;
CodeTypeMap.TryGetValue(Constants.RESPONSE_STATUS_TYPE_NAME, out responseStatusType);
Enforce.IsNotNull <CodeTypeDeclaration>(responseStatusType, string.Format("Weird code generator internal error, missing requried {0}, please ask soa framework team for help.", Constants.RESPONSE_STATUS_TYPE_NAME));
if (!CodeExtension.IsSOACommonType(responseStatusType))
{
throw new SOAPolicyViolationException(string.Format(" SOA Policy Violation, {0} reference is not SOA Common {1}.", Constants.RESPONSE_STATUS_TYPE_NAME, Constants.RESPONSE_STATUS_TYPE_NAME));
}
if (!CodeExtension.HasInterface(responseType, HAS_RESPONSE_STATUS_INTERFACE_NAME))
{
// make response type implement IHasResponseStatus interface
responseType.BaseTypes.Add(HAS_RESPONSE_STATUS_INTERFACE_NAME);
}
// optional common request handling
CodeTypeDeclaration requestType = null;
CodeTypeMap.TryGetValue(requestTypeName, out requestType);
Enforce.IsNotNull <CodeTypeDeclaration>(requestType, "Weird code generator internal error, please ask soa framework team for help.");
if (isHealthCheckOperation)
{
//healthCheckRequestType = requestType;
}
if (CodeExtension.HasProperty(requestType, MOBILE_REQUEST_HEAD_PROPERTY_NAME, MOBILE_REQUEST_HEAD_TYPE_NAME) &&
!CodeExtension.HasInterface(requestType, HAS_MOBILE_REQUEST_HEAD_INTERFACE_NAME))
{
requestType.BaseTypes.Add(HAS_MOBILE_REQUEST_HEAD_INTERFACE_NAME);
}
if (CodeExtension.HasProperty(responseType, Constants.COMMON_REQUEST_PROPERTY_NAME, Constants.COMMON_REQUEST_TYPE_NAME))
{
CodeTypeDeclaration commonRequestType = null;
CodeTypeMap.TryGetValue(Constants.COMMON_REQUEST_TYPE_NAME, out commonRequestType);
Enforce.IsNotNull <CodeTypeDeclaration>(commonRequestType, string.Format("Weird code generator internal error, missing requried {0}, please ask soa framework team for help.", Constants.COMMON_REQUEST_TYPE_NAME));
if (!CodeExtension.IsSOACommonType(commonRequestType))
{
throw new SOAPolicyViolationException(string.Format(" SOA Policy Violation, {0} reference is not Ant SOA Common {1}.", Constants.COMMON_REQUEST_TYPE_NAME, Constants.COMMON_REQUEST_TYPE_NAME));
}
if (!CodeExtension.HasInterface(responseType, HAS_COMMON_REQUEST_INTERFACE_NAME))
{
// make request type implement IHasCommonRequest interface
responseType.BaseTypes.Add(HAS_COMMON_REQUEST_INTERFACE_NAME);
}
}
// Generate operation documentation
if (!string.IsNullOrEmpty(operation.Documentation))
{
CodeDomHelper.CreateSummaryComment(method.Comments, operation.Documentation);
}
interfaceType.Members.Add(method);
}
if (hasAsync)
{
imports.Add(new CodeNamespaceImport(Constants.SYSTEM_THREADING_TASKS_NAMESPACE));
}
// SOA Policy enforcement : healtch check operation is mandatory
//if (healthCheckRequestType == null || healthCheckResponseType == null)
//{
// throw new SOAPolicyViolationException(string.Format("SOA Policy Violation, missing mandatory check health operation."));
//}
//if (!CodeExtension.IsSOACommonType(healthCheckRequestType) || !CodeExtension.IsSOACommonType(healthCheckResponseType))
//{
// throw new SOAPolicyViolationException(string.Format("SOA Policy Violation, wrong SOA common healthcheck types."));
//}
if (generatorMode == CodeGeneratorMode.Service)
{
codeType = interfaceType;
return;
}
imports.Add(new CodeNamespaceImport(SYSTEM_NAMESPACE));
imports.Add(new CodeNamespaceImport(SYSTEM_THREADING_NAMESPACE));
imports.Add(new CodeNamespaceImport(SYSTEM_THREADING_TASKS_NAMESPACE));
imports.Add(new CodeNamespaceImport(
generatorMode == CodeGeneratorMode.Client ? C_SERVICE_STACK_SERVICE_CLIENT_NAMESPACE : C_SERVICE_STACK_AUTOMATION_TEST_CLIENT_NAMESPACE));
string clientName = interfaceContract.ServiceName.Replace("Interface", string.Empty) + "Client";
CodeTypeDeclaration clientType = new CodeTypeDeclaration(clientName);
clientType.UserData.Add(Constants.GENERATED_TYPE, clientName);
var baseType = new CodeTypeReference(
generatorMode == CodeGeneratorMode.Client ? SERVICE_CLIENT_BASE_NAME : SERVICE_CLIENT_FOR_AUTOMATION_BASE_NAME,
new CodeTypeReference[] { new CodeTypeReference(clientName) });
clientType.BaseTypes.Add(baseType);
codeType = clientType;
// Generate client documentation
string clientDoc = "Service client auto-generated by SOA tool, DO NOT CHANGE!\n\n";
if (!string.IsNullOrEmpty(interfaceContract.ServiceDocumentation))
{
clientDoc += interfaceContract.ServiceDocumentation;
}
CodeDomHelper.CreateSummaryComment(clientType.Comments, clientDoc);
// base constructor
//CodeConstructor baseConstructor = new CodeConstructor();
//baseConstructor.Attributes = MemberAttributes.Public;
//baseConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(""));
//clientType.Members.Add(baseConstructor);
// public constant string service name and namespace
CodeMemberField codeMemberField = new CodeMemberField(typeof(string), SERVICE_CLIENT_CODE_GENERATOR_VERSION_FIELD_NAME);
codeMemberField.Attributes = (codeMemberField.Attributes & ~MemberAttributes.AccessMask & ~MemberAttributes.ScopeMask) | MemberAttributes.Public | MemberAttributes.Const;
codeMemberField.InitExpression = new CodePrimitiveExpression(typeof(InterfaceContractGenerator).Assembly.GetName().Version.ToString());
clientType.Members.Add(codeMemberField);
codeMemberField = new CodeMemberField(typeof(string), SERVICE_CLIENT_ORIGINAL_SERVICE_NAME_FIELD_NAME);
codeMemberField.Attributes = (codeMemberField.Attributes & ~MemberAttributes.AccessMask & ~MemberAttributes.ScopeMask) | MemberAttributes.Public | MemberAttributes.Const;
codeMemberField.InitExpression = new CodePrimitiveExpression(interfaceContract.ServiceName);
clientType.Members.Add(codeMemberField);
codeMemberField = new CodeMemberField(typeof(string), SERVICE_CLIENT_ORIGINAL_SERVICE_NAMESPACE_FIELD_NAME);
codeMemberField.Attributes = (codeMemberField.Attributes & ~MemberAttributes.AccessMask & ~MemberAttributes.ScopeMask) | MemberAttributes.Public | MemberAttributes.Const;
codeMemberField.InitExpression = new CodePrimitiveExpression(interfaceContract.ServiceNamespace);
clientType.Members.Add(codeMemberField);
codeMemberField = new CodeMemberField(typeof(string), SERVICE_CLIENT_ORIGINAL_SERVICE_TYPE_FIELD_NAME);
codeMemberField.Attributes = (codeMemberField.Attributes & ~MemberAttributes.AccessMask & ~MemberAttributes.ScopeMask) | MemberAttributes.Public | MemberAttributes.Const;
codeMemberField.InitExpression = new CodePrimitiveExpression(SERVICE_CLIENT_NON_SLB_SERVICE_TYPE_FIELD_NAME);
clientType.Members.Add(codeMemberField);
// private constructor with baseUri parameter
CodeConstructor baseConstructorWithParameter = new CodeConstructor();
baseConstructorWithParameter.Attributes = MemberAttributes.Private;
baseConstructorWithParameter.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "baseUri"));
baseConstructorWithParameter.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("baseUri"));
clientType.Members.Add(baseConstructorWithParameter);
// private constructor with serviceName & serviceNamespace parameter
baseConstructorWithParameter = new CodeConstructor();
baseConstructorWithParameter.Attributes = MemberAttributes.Private;
baseConstructorWithParameter.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "serviceName"));
baseConstructorWithParameter.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("serviceName"));
baseConstructorWithParameter.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "serviceNamespace"));
baseConstructorWithParameter.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("serviceNamespace"));
baseConstructorWithParameter.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "subEnv"));
baseConstructorWithParameter.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("subEnv"));
clientType.Members.Add(baseConstructorWithParameter);
// build methods
foreach (Operation operation in interfaceContract.OperationsCollection)
{
string operationName = operation.Name;
Message inMessage = operation.Input;
XmlQualifiedName inMessageElementQName = new XmlQualifiedName(inMessage.Element.ElementName, inMessage.Element.ElementNamespace);
string requestTypeName = null;
ElementName2TypeNameMapping.TryGetValue(inMessageElementQName, out requestTypeName);
Message outMessage = operation.Output;
XmlQualifiedName outMessageElementQName = new XmlQualifiedName(outMessage.Element.ElementName, outMessage.Element.ElementNamespace);
string responseTypeName = null;
ElementName2TypeNameMapping.TryGetValue(outMessageElementQName, out responseTypeName);
CodeTypeReference responseType = new CodeTypeReference(responseTypeName);
BuildSyncMethod(clientType, operation, requestTypeName, responseTypeName);
BuildSyncWithCallbackMethod(clientType, operation, requestTypeName, responseTypeName);
BuildCreateRequestTaskMethod(clientType, operation, requestTypeName, responseTypeName);
BuildStartIOCPTaskMethod(clientType, operation, requestTypeName, responseTypeName);
}
}
/// <summary>
/// Generates the <see cref="CodeNamespace"/> based on the provide context.
/// </summary>
/// <param name="codeGeneratorContext">The code generator context.</param>
public CodeNamespace[] GenerateCodes(ICodeGeneratorContext codeGeneratorContext)
{
CodeGenOptions codeGenOptions = codeGeneratorContext.CodeGenOptions;
XmlSchemas xmlSchemas = codeGeneratorContext.XmlSchemas;
List <CodeNamespace> codeNamespaces = new List <CodeNamespace>();
// Generate DataContracts
const CodeGenerationOptions generationOptions = CodeGenerationOptions.GenerateProperties;
IDictionary <string, XmlSchemaType> typeName2schemaTypeMapping = codeGeneratorContext.TypeName2schemaTypeMapping;
IDictionary <XmlQualifiedName, string> elementName2TypeNameMapping = codeGeneratorContext.ElementName2TypeNameMapping;
IDictionary <string, string> elementName2TargetNamespaceMapping = codeGeneratorContext.ElementName2TargetNamespaceMapping;
foreach (XmlSchema schema in xmlSchemas)
{
CodeNamespace codeNamespace = new CodeNamespace();
codeNamespace.UserData.Add(Constants.SCHEMA, schema);
// TypeName to XmlSchemaType mapping
XmlCodeExporter exporter = new XmlCodeExporter(codeNamespace);
XmlSchemaImporter importer = new XmlSchemaImporter(xmlSchemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));
foreach (XmlSchemaElement element in schema.Elements.Values)
{
XmlTypeMapping typeMapping = importer.ImportTypeMapping(element.QualifiedName);
if (element.IsAbstract)
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
if (typeMapping.XsdTypeName == "anyType")
{
continue; // ignore no type element
}
if (string.IsNullOrWhiteSpace(typeMapping.XsdTypeName))
{
throw new Exception("Cannot use anonymous type for Request/Response element: " + element.Name + ".");
}
typeName2schemaTypeMapping[typeMapping.XsdTypeName] = element.ElementSchemaType;
elementName2TypeNameMapping[element.QualifiedName] = typeMapping.XsdTypeName;
elementName2TargetNamespaceMapping[element.QualifiedName.Name] = schema.TargetNamespace;
}
foreach (XmlSchemaType schemaType in schema.SchemaTypes.Values)
{
if (String.IsNullOrWhiteSpace(schemaType.SourceUri))
{
schemaType.SourceUri = schema.SourceUri;
}
XmlTypeMapping typeMapping = importer.ImportSchemaType(schemaType.QualifiedName);
if (DataContractGenerator.CouldBeAnArray(schemaType))
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
typeName2schemaTypeMapping[typeMapping.TypeName] = schemaType;
}
if (codeNamespace.Types.Count > 0)
{
codeNamespaces.Add(codeNamespace);
}
}
if (codeNamespaces.Count == 0)
{
throw new Exception("No types were generated.");
}
// Build type name to code type declaration mapping
codeGeneratorContext.CodeTypeMap = DataContractGenerator.BuildCodeTypeMap(codeNamespaces.ToArray());
for (int i = 0; i < codeNamespaces.Count; i++)
{
CodeNamespace codeNamespace = codeNamespaces[i];
// Decorate data contracts code
ICodeExtension codeExtension = new CodeExtension();
codeExtension.Process(codeNamespace, codeGeneratorContext);
// Import SOA common type namespace before removing code types
codeNamespace.Imports.Add(new CodeNamespaceImport(Constants.C_SERVICE_STACK_COMMON_TYPES_NAMESPACE));
// Remove SOA common types since they have already been included in CSerivceStack DLL
CodeExtension.RemoveSOACommonTypes(codeNamespace);
CodeExtension.RemoveDefaultTypes(codeNamespace);
XmlSchema schema = codeNamespace.UserData[Constants.SCHEMA] as XmlSchema;
List <CodeTypeDeclaration> types = new List <CodeTypeDeclaration>();
foreach (XmlSchemaType schemaType in schema.SchemaTypes.Values)
{
foreach (CodeTypeDeclaration codeType in codeNamespace.Types)
{
if (codeType.Name == schemaType.Name &&
schema.SourceUri == schemaType.SourceUri)
{
types.Add(codeType);
}
}
}
codeNamespace.Types.Clear();
codeNamespace.Types.AddRange(types.ToArray());
if (codeNamespace.Types.Count == 0)
{
codeNamespaces.RemoveAt(i--);
}
}
codeNamespaces.ImplementsBaijiSerialization(codeGeneratorContext);
//Add Interface CodeNamespace
CodeNamespace interfaceNamespace = new CodeNamespace(codeGenOptions.ClrNamespace);
// Generate interface code
string wsdlFile = codeGeneratorContext.CodeGenOptions.MetadataLocation;
InterfaceContract interfaceContract = ServiceDescriptionEngine.GetInterfaceContract(wsdlFile);
CodeTypeDeclaration interfaceType;
CodeNamespaceImportCollection imports;
this.buildInterfaceCode(codeGeneratorContext, interfaceContract, out interfaceType, out imports);
interfaceNamespace.Types.Add(interfaceType);
foreach (CodeNamespaceImport @import in imports)
{
interfaceNamespace.Imports.Add(@import);
}
// Import SOA common type namespace before removing code types
interfaceNamespace.Imports.Add(new CodeNamespaceImport(Constants.C_SERVICE_STACK_COMMON_TYPES_NAMESPACE));
// Remove SOA common types since they have already been included in CSerivceStack DLL
CodeExtension.RemoveSOACommonTypes(interfaceNamespace);
CodeExtension.RemoveDefaultTypes(interfaceNamespace);
string fileName = null;
if (codeGeneratorContext.CodeGenOptions.CodeGeneratorMode == CodeGeneratorMode.Service)
{
fileName = "I" + interfaceContract.ServiceName.Replace("Interface", string.Empty);
}
else
{
fileName = interfaceContract.ServiceName.Replace("Interface", string.Empty) + "Client";
}
interfaceNamespace.UserData.Add(Constants.FILE_NAME, fileName);
codeNamespaces.Add(interfaceNamespace);
return(codeNamespaces.ToArray());
}
/// <summary>
/// Generates the <see cref="CodeNamespace"/> based on the provide context.
/// </summary>
/// <param name="codeGeneratorContext">The code generator context.</param>
public CodeNamespace[] GenerateCodes(ICodeGeneratorContext codeGeneratorContext)
{
CodeGenOptions codeGenOptions = codeGeneratorContext.CodeGenOptions;
XmlSchemas xmlSchemas = codeGeneratorContext.XmlSchemas;
// Generate DataContracts
const CodeGenerationOptions generationOptions = CodeGenerationOptions.GenerateProperties;
List <CodeNamespace> codeNamespaces = new List <CodeNamespace>();
// TypeName to XmlSchemaType mapping
IDictionary <string, XmlSchemaType> typeName2schemaTypeMapping = codeGeneratorContext.TypeName2schemaTypeMapping;
foreach (XmlSchema schema in xmlSchemas)
{
CodeNamespace codeNamespace = new CodeNamespace();
codeNamespace.UserData.Add(Constants.SCHEMA, schema);
XmlCodeExporter exporter = new XmlCodeExporter(codeNamespace);
XmlSchemaImporter importer = new XmlSchemaImporter(xmlSchemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));
foreach (XmlSchemaElement element in schema.Elements.Values)
{
XmlTypeMapping typeMapping = importer.ImportTypeMapping(element.QualifiedName);
if (element.IsAbstract)
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
typeName2schemaTypeMapping[typeMapping.TypeName] = element.ElementSchemaType;
}
foreach (XmlSchemaType schemaType in schema.SchemaTypes.Values)
{
if (String.IsNullOrWhiteSpace(schemaType.SourceUri))
{
schemaType.SourceUri = schema.SourceUri;
}
XmlTypeMapping typeMapping = importer.ImportSchemaType(schemaType.QualifiedName);
if (CouldBeAnArray(schemaType))
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
typeName2schemaTypeMapping[typeMapping.TypeName] = schemaType;
}
if (codeNamespace.Types.Count > 0)
{
codeNamespaces.Add(codeNamespace);
}
}
if (codeNamespaces.Count == 0)
{
throw new Exception("No types were generated.");
}
// Build type name to code type declaration mapping
codeGeneratorContext.CodeTypeMap = DataContractGenerator.BuildCodeTypeMap(codeNamespaces.ToArray());
if (codeGenOptions.ForceElementName)
{
DataContractGenerator.BuildElementName2TypeNameMapping(codeGeneratorContext);
}
if (codeGenOptions.ForceElementNamespace)
{
DataContractGenerator.BuildElementName2TargetNamespaceMapping(codeGeneratorContext);
}
for (int i = 0; i < codeNamespaces.Count; i++)
{
CodeNamespace codeNamespace = codeNamespaces[i];
// Decorate data contracts code
ICodeExtension codeExtension = new CodeExtension();
codeExtension.Process(codeNamespace, codeGeneratorContext);
CodeExtension.RemoveDefaultTypes(codeNamespace);
List <CodeTypeDeclaration> types = new List <CodeTypeDeclaration>();
XmlSchema schema = codeNamespace.UserData[Constants.SCHEMA] as XmlSchema;
foreach (XmlSchemaType schemaType in schema.SchemaTypes.Values)
{
foreach (CodeTypeDeclaration codeType in codeNamespace.Types)
{
if (codeType.Name == schemaType.Name &&
schema.SourceUri == schemaType.SourceUri)
{
types.Add(codeType);
}
}
}
codeNamespace.Types.Clear();
codeNamespace.Types.AddRange(types.ToArray());
if (codeNamespace.Types.Count == 0)
{
codeNamespaces.RemoveAt(i--);
}
}
return(codeNamespaces.ToArray());
}
/// <summary>
/// Generates the <see cref="CodeNamespace"/> based on the provide context.
/// </summary>
/// <param name="codeGeneratorContext">The code generator context.</param>
public CodeNamespace GenerateCode(ICodeGeneratorContext codeGeneratorContext)
{
CodeGenOptions codeGenOptions = codeGeneratorContext.CodeGenOptions;
XmlSchemas xmlSchemas = codeGeneratorContext.XmlSchemas;
CodeNamespace codeNamespace = new CodeNamespace();
// Generate DataContracts
const CodeGenerationOptions generationOptions = CodeGenerationOptions.GenerateProperties;
var exporter = new XmlCodeExporter(codeNamespace);
var importer = new XmlSchemaImporter(xmlSchemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));
// TypeName to XmlSchemaType mapping
IDictionary <string, XmlSchemaType> typeName2schemaTypeMapping = codeGeneratorContext.TypeName2schemaTypeMapping;
foreach (XmlSchema schema in xmlSchemas)
{
foreach (XmlSchemaElement element in schema.Elements.Values)
{
XmlTypeMapping typeMapping = importer.ImportTypeMapping(element.QualifiedName);
if (element.IsAbstract)
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
typeName2schemaTypeMapping[typeMapping.TypeName] = element.ElementSchemaType;
}
foreach (XmlSchemaType complexType in schema.SchemaTypes.Values)
{
XmlTypeMapping typeMapping = importer.ImportSchemaType(complexType.QualifiedName);
if (CouldBeAnArray(complexType))
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
typeName2schemaTypeMapping[typeMapping.TypeName] = complexType;
}
}
if (codeNamespace.Types.Count == 0)
{
throw new Exception("No types were generated.");
}
// Build type name to code type declaration mapping
codeGeneratorContext.CodeTypeMap = BuildCodeTypeMap(codeNamespace);
if (codeGenOptions.ForceElementName)
{
DataContractGenerator.BuildElementName2TypeNameMapping(codeGeneratorContext);
}
if (codeGenOptions.ForceElementNamespace)
{
DataContractGenerator.BuildElementName2TargetNamespaceMapping(codeGeneratorContext);
}
// Decorate data contracts code
ICodeExtension codeExtension = new CodeExtension();
codeExtension.Process(codeNamespace, codeGeneratorContext);
CodeExtension.RemoveDefaultTypes(codeNamespace);
return(codeNamespace);
}
public override void CreateCode(Node node, CodeExtension codeExtension)
{
//Nothing to generate!
}
public override void CreateCode(Node node, CodeExtension codeExtension)
{
var nodeClass = node.Class as TransformationNodeClass;
codeExtension.AddTransformation(node as Transformation);
codeExtension.AddExtras(nodeClass.NeededExtras);
var content = "";
var args = "(";
var currentTransform = codeExtension.GetCurrentStep();
for (var i = 0; i < nodeClass.InputTypes.Length; i++)
{
var inputType = nodeClass.InputTypes[i];
var inputNode = node.InputNodes[i];
var ioData = node.InputIOData[i];
//If we have a combined node, we have to proxy it's output node:
if (inputNode is CombinedNode)
{
inputNode = ((CombinedNode)inputNode).outputNode;
}
//Add the args:
if (i != 0)
{
args += ", ";
}
args += "data" + i;
if (inputNode == null)
{
//We have a default value in the GUI:
content += string.Format(ClassTemplates.GENERATION_TEMPLATE_TRANSFORM_VAR_LINE_STATIC,
inputType.MinimizedName,
i,
ioData.Value);
}
else
{
var inAsSource = inputNode as DataSource;
var inAsTransform = inputNode as Transformation;
var inAsBuffer = inputNode as BufferNode;
var inAsSourceClass = inAsSource?.Class as DataSourceNodeClass;
var inAsTransClass = inAsTransform?.Class as TransformationNodeClass;
var inAsBufferClass = inAsBuffer?.Class as BufferNodeClass;
var typeName = "";
var optionalMethodCall = "";
switch (inputNode.Class.NodeType)
{
case ClassManager.NodeType.Transformation:
typeName = "transform";
break;
case ClassManager.NodeType.Sensor:
typeName = "sensor";
optionalMethodCall = "." + inAsSourceClass.DataMethod + "()";
break;
case ClassManager.NodeType.Buffer:
typeName = "buffer";
optionalMethodCall = "." + inAsBufferClass.BufferGetMethod + "()";
break;
case ClassManager.NodeType.Combined:
break;
default:
throw new ArgumentOutOfRangeException();
}
var outputIndex = codeExtension.GetOutputIndex(inputNode);
content += string.Format(ClassTemplates.GENERATION_TEMPLATE_TRANSFORM_VAR_LINE,
inputType.MinimizedName,
i,
typeName,
outputIndex,
optionalMethodCall);
}
}
args += ")";
//Extract the method call:
var methodCall = (nodeClass.IsStatic
? (DataType.MinimizeToClass(nodeClass.MainClass))
: (nodeClass.NodeType.ToString() + codeExtension.GetTransformId(node as Transformation)))
+ "." + nodeClass.Method + args;
var template = codeExtension.RootNode == node
? ClassTemplates.GENERATION_TEMPLATE_TRANSFORM_LAST
: ClassTemplates.GENERATION_TEMPLATE_TRANSFORM;
var code = string.Format(
template,
currentTransform,
content,
methodCall
);
//At last add the important stuff:
codeExtension.AddCodeStep(code);
codeExtension.AddImport(nodeClass.MainClass);
codeExtension.AddImport(nodeClass.OutputType.Name);
//Add the proxy methods to the Imports:
nodeClass.ProxyProperties
.Select(p => p.PropertyType.Name)
.ForEach(codeExtension.AddImport);
}
/// <summary>
/// Generates the <see cref="CodeNamespace"/> based on the provide context.
/// </summary>
/// <param name="codeGeneratorContext">The code generator context.</param>
public CodeNamespace GenerateCode(ICodeGeneratorContext codeGeneratorContext)
{
CodeGenOptions codeGenOptions = codeGeneratorContext.CodeGenOptions;
XmlSchemas xmlSchemas = codeGeneratorContext.XmlSchemas;
CodeNamespace codeNamespace = new CodeNamespace();
// Generate DataContracts
const CodeGenerationOptions generationOptions = CodeGenerationOptions.GenerateProperties;
var exporter = new XmlCodeExporter(codeNamespace);
var importer = new XmlSchemaImporter(xmlSchemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));
// TypeName to XmlSchemaType mapping
IDictionary <string, XmlSchemaType> typeName2schemaTypeMapping = codeGeneratorContext.TypeName2schemaTypeMapping;
IDictionary <XmlQualifiedName, string> elementName2TypeNameMapping = codeGeneratorContext.ElementName2TypeNameMapping;
IDictionary <string, string> elementName2TargetNamespaceMapping = codeGeneratorContext.ElementName2TargetNamespaceMapping;
foreach (XmlSchema schema in xmlSchemas)
{
foreach (XmlSchemaElement element in schema.Elements.Values)
{
XmlTypeMapping typeMapping = importer.ImportTypeMapping(element.QualifiedName);
if (element.IsAbstract)
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
if (typeMapping.XsdTypeName == "anyType")
{
continue; // ignore no type element
}
if (string.IsNullOrWhiteSpace(typeMapping.XsdTypeName))
{
throw new Exception("Cannot use anonymous type for Request/Response element: " + element.Name + ".");
}
typeName2schemaTypeMapping[typeMapping.XsdTypeName] = element.ElementSchemaType;
elementName2TypeNameMapping[element.QualifiedName] = typeMapping.XsdTypeName;
elementName2TargetNamespaceMapping[element.QualifiedName.Name] = schema.TargetNamespace;
}
foreach (XmlSchemaType complexType in schema.SchemaTypes.Values)
{
XmlTypeMapping typeMapping = importer.ImportSchemaType(complexType.QualifiedName);
if (DataContractGenerator.CouldBeAnArray(complexType))
{
continue;
}
exporter.ExportTypeMapping(typeMapping);
typeName2schemaTypeMapping[typeMapping.TypeName] = complexType;
}
}
if (codeNamespace.Types.Count == 0)
{
throw new Exception("No types were generated.");
}
// Build type name to code type declaration mapping
codeGeneratorContext.CodeTypeMap = DataContractGenerator.BuildCodeTypeMap(codeNamespace);
// Decorate data contracts code
ICodeExtension codeExtension = new CodeExtension();
codeExtension.Process(codeNamespace, codeGeneratorContext);
codeNamespace.ImplementsBaijiSerialization(codeGeneratorContext);
// Generate interface code
string wsdlFile = codeGeneratorContext.CodeGenOptions.MetadataLocation;
InterfaceContract interfaceContract = ServiceDescriptionEngine.GetInterfaceContract(wsdlFile);
CodeTypeDeclaration codeType;
CodeNamespaceImportCollection imports;
this.buildInterfaceCode(codeGeneratorContext, interfaceContract, out codeType, out imports);
codeNamespace.Types.Add(codeType);
foreach (CodeNamespaceImport @import in imports)
{
codeNamespace.Imports.Add(@import);
}
// Import SOA common type namespace before removing code types
codeNamespace.Imports.Add(new CodeNamespaceImport(Constants.C_SERVICE_STACK_COMMON_TYPES_NAMESPACE));
// Remove SOA common types since they have already been included in CSerivceStack DLL
CodeExtension.RemoveSOACommonTypes(codeNamespace);
CodeExtension.RemoveDefaultTypes(codeNamespace);
return(codeNamespace);
}
public override void save(string directory, string javaClass, CodeExtension codeExtension)
{
//Check if we have a Android studio Folder:
string manifestPath = SearchManifest(directory);
if (manifestPath == null)
{
return;
}
//We have a manifest!
//Now navigate to the Source-Path:
DirectoryInfo androidStudioProjectPath = Directory.GetParent(manifestPath).Parent.Parent;
DirectoryInfo androidStudioWorkspacePath = androidStudioProjectPath.Parent;
string projectName = androidStudioProjectPath.Name;
string workspacePath = androidStudioWorkspacePath.FullName;
//Add the Extras:
AddExtrasToManifest(manifestPath, codeExtension.GetExtras());
//Copy classes:
string javaDirPath = Directory.GetParent(manifestPath).FullName;
javaDirPath = Path.Combine(javaDirPath, "java");
Directory.CreateDirectory(javaDirPath);
CopyJavaFile(javaDirPath, javaClass, codeExtension);
CopyNodes(javaDirPath, codeExtension.GetAllUsedNodes());
//Copy lib:
string libPath = Path.Combine(androidStudioProjectPath.FullName, "libs");
Directory.CreateDirectory(libPath);
CopyLibs(libPath);
//Add lib to Gradle file:
string gradlePath = Path.Combine(androidStudioProjectPath.FullName, "build.gradle");
if (File.Exists(gradlePath))
{
string gradleFile = File.ReadAllText(gradlePath);
if (!gradleFile.Contains("dirs 'libs'"))
{
//Check if we have an easy go:
if (gradleFile.Contains("mavenCentral()"))
{
gradleFile = gradleFile.Replace("mavenCentral()", "mavenCentral()\n flatDir {\n dirs 'libs'\n }\n");
}
else
{
gradleFile +=
"\n" +
"repositories {\n" +
" mavenCentral()\n" +
" flatDir {\n" +
" dirs 'libs'\n" +
" }\n" +
"}\n";
}
//Add Lib dependencies:
gradleFile = gradleFile.ReplaceFirst("dependencies {",
"dependencies {\n" +
" compile 'de.tu_darmstadt.smastra.base:SmaSTraBase:1.0@aar'"
);
//Finally rewrite:
File.WriteAllText(gradlePath, gradleFile);
}
}
else
{
MessageBox.Show("Did not find the build.gradle, please edit it by hand!", "File not found: build.gradle");
}
}
/// <summary> /// Creates the Code for the Node and stores it in the code-Extension. /// </summary> /// <param name="node">To use</param> /// <param name="codeExtension">To use.</param> public abstract void CreateCode(Node node, CodeExtension codeExtension);
