protected Task WriteMethodGroupMappersFile(MethodGroupTS methodGroup)
        {
            string filePath = GetSourceCodeFilePath(methodGroup.CodeModelTS, "models", methodGroup.MappersModuleName + ".ts");

            return(Write(new MethodGroupMappersTemplate {
                Model = methodGroup
            }, filePath));
        }
Example #2
0
        protected Task WriteMethodGroupFile(MethodGroupTS methodGroup)
        {
            CodeModelTS codeModel = methodGroup.CodeModelTS;
            string      filePath  = GetSourceCodeFilePath(codeModel, "operations", methodGroup.TypeName.ToCamelCase() + ".ts");

            return(Write(new MethodGroupTemplate {
                Model = methodGroup
            }, filePath));
        }
        protected Task WriteMethodGroupFile(MethodGroupTS methodGroup)
        {
            CodeModelTS codeModel = methodGroup.CodeModelTS;
            string      typeName  = methodGroup.TypeName.ToCamelCase();
            string      filePath  = GetSourceCodeFilePath(codeModel, "handlers", methodGroup.HandlerInterfaceName + ".ts");

            return(Write(new MethodGroupTemplate {
                Model = methodGroup
            }, filePath));
        }
Example #4
0
        public static MethodTS Method(
            HttpMethod httpMethod                = HttpMethod.Get,
            string requestContentType            = null,
            CodeModelTS codeModel                = null,
            MethodGroupTS methodGroup            = null,
            Response defaultResponse             = null,
            IEnumerable <ParameterTS> parameters = null,
            string deprecatedMessage             = null)
        {
            if (codeModel == null)
            {
                codeModel = CodeModel();
            }

            MethodTS method = DependencyInjection.New <MethodTS>();

            if (methodGroup == null)
            {
                methodGroup = MethodGroup(codeModel);
            }
            method.MethodGroup = methodGroup;

            codeModel.Add(method);

            method.HttpMethod         = httpMethod;
            method.RequestContentType = requestContentType;

            method.DefaultResponse = defaultResponse;

            if (parameters != null)
            {
                foreach (ParameterTS parameter in parameters)
                {
                    method.Add(parameter);
                }
            }

            method.DeprecationMessage = deprecatedMessage;

            return(method);
        }
Example #5
0
        public static MethodGroupTS MethodGroup(CodeModelTS codeModel = null, IEnumerable <MethodTS> methods = null)
        {
            if (codeModel == null)
            {
                codeModel = CodeModel();
            }

            MethodGroupTS methodGroup = DependencyInjection.New <MethodGroupTS>();

            codeModel.Add(methodGroup);

            if (methods != null)
            {
                foreach (MethodTS method in methods)
                {
                    methodGroup.Add(method);
                }
            }

            return(methodGroup);
        }
Example #6
0
        protected Task WriteMethodGroupMappersFile(MethodGroupTS methodGroup)
        {
            string filePath = GetSourceCodeFilePath(methodGroup.CodeModelTS, "models", methodGroup.MappersModuleName + ".ts");

            return(Write(methodGroup.GenerateMappers(), filePath));
        }