public virtual void Write(ICodeFragment fragment, IOutputCache output) { DeclareTemplate template = (DeclareTemplate)fragment; output.Add(template.IsConstant ? "const " : "let ") .Add(template.Name) .If(template.Type != null && !(template.Code is NewTemplate)).Add(": ").Add(template.Type).EndIf() .Add(" = ") .Add(template.Code) .CloseLine(); }
public virtual void Write(ICodeFragment fragment, IOutputCache output) { DeclareTemplate template = (DeclareTemplate)fragment; output.Add(template.Type) .Add(" ") .Add(template.Name) .Add(" = ") .Add(template.Code) .CloseLine(); }
public static LocalVariableTemplate Local(this ChainedCodeFragment template, DeclareTemplate type) { return(new LocalVariableTemplate(type.Name).Chain(template)); }
public virtual void Write(AspDotNetWriteConfiguration configuration, List <ITransferObject> transferObjects, List <FileTemplate> files) { if (!configuration.Language.IsCsharp()) { throw new InvalidOperationException($"Can not generate ASP.net Controller for language {configuration.Language?.Name ?? "Empty"}. Only Csharp is currently implemented"); } foreach (AspDotNetWriteEntityControllerConfiguration controllerConfiguration in configuration.Controllers) { EntityTransferObject entity = transferObjects.OfType <EntityTransferObject>().FirstOrDefault(x => x.Name == controllerConfiguration.Entity) .AssertIsNotNull(nameof(controllerConfiguration.Entity), $"Entity {controllerConfiguration.Entity} not found. Ensure it is read before."); string nameSpace = (controllerConfiguration.Namespace ?? configuration.Namespace).AssertIsNotNull(nameof(configuration.Namespace), "asp writer requires a namespace"); ClassTemplate controller = files.AddFile(configuration.RelativePath, configuration.AddHeader) .AddNamespace(nameSpace) .AddClass(controllerConfiguration.Name ?? entity.Name + "Controller", Code.Type(configuration.Template.ControllerBase)) .FormatName(configuration) .WithAttribute("Route", Code.String(controllerConfiguration.Route ?? "[controller]")); controller.Usings.AddRange(configuration.Template.Usings); TypeTemplate modelType = entity.Model.ToTemplate(); configuration.Usings.ForEach(x => controller.AddUsing(x)); controllerConfiguration.Usings.ForEach(x => controller.AddUsing(x)); FieldTemplate repositoryField = controller.AddField("repository", Code.Type(entity.Name + "Repository")).Readonly(); controller.AddConstructor().Code.AddLine(Code.This().Field(repositoryField).Assign(Code.New(repositoryField.Type)).Close()); if (controllerConfiguration.Get != null) { controller.AddUsing("System.Linq"); MethodTemplate method = controller.AddMethod("Get", Code.Generic("IEnumerable", modelType)); if (configuration.Template.UseAttributes) { method.WithAttribute("HttpGet", Code.String(controllerConfiguration.Get.Name ?? "[action]")); } DeclareTemplate queryable = Code.Declare(Code.Generic("IQueryable", modelType), "queryable", Code.This().Field(repositoryField).Method("Get")); method.Code.AddLine(queryable); foreach (PropertyTransferObject property in entity.Model.Properties) { ParameterTemplate parameter = method.AddParameter(property.Type.ToTemplate(), property.Name, Code.Local("default")).FormatName(configuration); method.Code.AddLine(Code.If(Code.Local(parameter).NotEquals().Local("default"), x => x.Code.AddLine(Code.Local(queryable).Assign(Code.Local(queryable).Method("Where", Code.Lambda("x", Code.Local("x").Property(property.Name).Equals().Local(parameter)))).Close()))); } method.Code.AddLine(Code.Return(Code.Local(queryable))); } if (controllerConfiguration.Post != null) { MethodTemplate method = controller.AddMethod("Post", Code.Void()); if (configuration.Template.UseAttributes) { method.WithAttribute("HttpPost", Code.String(controllerConfiguration.Post.Name ?? "[action]")); } ParameterTemplate parameter = method.AddParameter(modelType, "entity") .WithAttribute("FromBody"); method.Code.AddLine(Code.This().Field(repositoryField).Method("Add", Code.Local(parameter)).Close()); } if (controllerConfiguration.Patch != null) { MethodTemplate method = controller.AddMethod("Patch", Code.Void()); if (configuration.Template.UseAttributes) { method.WithAttribute("HttpPatch", Code.String(controllerConfiguration.Patch.Name ?? "[action]")); } ParameterTemplate parameter = method.AddParameter(modelType, "entity") .WithAttribute("FromBody"); method.Code.AddLine(Code.This().Field(repositoryField).Method("Update", Code.Local(parameter)).Close()); } if (controllerConfiguration.Put != null) { MethodTemplate method = controller.AddMethod("Put", Code.Void()); if (configuration.Template.UseAttributes) { method.WithAttribute("HttpPut", Code.String(controllerConfiguration.Put.Name ?? "[action]")); } ParameterTemplate parameter = method.AddParameter(modelType, "entity") .WithAttribute("FromBody"); method.Code.AddLine(Code.This().Field(repositoryField).Method("Update", Code.Local(parameter)).Close()); } if (controllerConfiguration.Delete != null) { MethodTemplate method = controller.AddMethod("Delete", Code.Void()); if (configuration.Template.UseAttributes) { method.WithAttribute("HttpDelete", Code.String(controllerConfiguration.Delete.Name ?? "[action]")); } List <ParameterTemplate> parameters = new List <ParameterTemplate>(); foreach (EntityKeyTransferObject key in entity.Keys) { PropertyTransferObject property = entity.Model.Properties.First(x => x.Name.Equals(key.Name, StringComparison.InvariantCultureIgnoreCase)); parameters.Add(method.AddParameter(property.Type.ToTemplate(), property.Name) .FormatName(configuration)); } method.Code.AddLine(Code.This().Field(repositoryField).Method("Delete", parameters.Select(x => Code.Local(x))).Close()); } } }
public static DeclareTemplate Constant(this DeclareTemplate template) { template.IsConstant = true; return(template); }
public static LocalVariableTemplate ToLocal(this DeclareTemplate template) { return(template == null ? null : Code.Instance.Local(template.Name)); }
public static LocalVariableTemplate Local(this Code _, DeclareTemplate type) { return(new LocalVariableTemplate(type.Name)); }
public virtual void Write(AngularWriteConfiguration configuration, List <ITransferObject> transferObjects, List <FileTemplate> files) { Logger.Trace("Generate angular service for ASP.net controller..."); if (!configuration.Language.IsTypeScript()) { throw new InvalidOperationException($"Can not generate service for ASP.net Controller for language {configuration.Language?.Name ?? "Empty"}"); } string httpClient = configuration.Service.HttpClient?.Name ?? "HttpClient"; string httpClientImport = configuration.Service.HttpClient?.Import ?? "@angular/common/http"; foreach (HttpServiceTransferObject controller in transferObjects.OfType <HttpServiceTransferObject>()) { Dictionary <HttpServiceActionParameterTransferObject, ParameterTemplate> mapping = new Dictionary <HttpServiceActionParameterTransferObject, ParameterTemplate>(); string controllerName = controller.Name.TrimEnd("Controller"); ClassTemplate classTemplate = files.AddFile(configuration.Service.RelativePath, configuration.AddHeader) .AddNamespace(string.Empty) .AddClass(configuration.Service.Name ?? controllerName + "Service") .FormatName(configuration) .WithUsing(httpClient, httpClientImport) .WithUsing("Injectable", "@angular/core") .WithUsing("Observable", "rxjs") .WithUsing("Subject", "rxjs") .WithAttribute("Injectable", Code.AnonymousObject().WithProperty("providedIn", Code.String("root"))); FieldTemplate httpField = classTemplate.AddField("http", Code.Type(httpClient)).Readonly().FormatName(configuration); FieldTemplate serviceUrlField = classTemplate.AddField("serviceUrl", Code.Type("string")).Public().FormatName(configuration).Default(Code.String(string.Empty)); classTemplate.AddConstructor().WithParameter(Code.Type(httpClient), "http") .WithCode(Code.This().Field(httpField).Assign(Code.Local("http")).Close()); string relativeModelPath = FileSystem.RelativeTo(configuration.Model?.RelativePath ?? ".", configuration.Service.RelativePath); foreach (HttpServiceActionTransferObject action in controller.Actions) { ICodeFragment errorCode = Code.Lambda("error", Code.Local("subject").Method("error", Code.Local("error"))); this.MapType(controller.Language, configuration.Language, action.ReturnType); TypeTemplate returnType = action.ReturnType.ToTemplate(); this.AddUsing(action.ReturnType, classTemplate, configuration, relativeModelPath); MethodTemplate methodTemplate = classTemplate.AddMethod(action.Name, Code.Generic("Observable", returnType)) .FormatName(configuration); foreach (HttpServiceActionParameterTransferObject parameter in action.Parameters) { this.MapType(controller.Language, configuration.Language, parameter.Type); this.AddUsing(parameter.Type, classTemplate, configuration, relativeModelPath); ParameterTemplate parameterTemplate = methodTemplate.AddParameter(parameter.Type.ToTemplate(), parameter.Name).FormatName(configuration); mapping.Add(parameter, parameterTemplate); } methodTemplate.AddParameter(Code.Type("{}"), "httpOptions?"); TypeTemplate subjectType = Code.Generic("Subject", returnType); methodTemplate.WithCode(Code.Declare(subjectType, "subject", Code.New(subjectType))); string uri = ("/" + (controller.Route?.Replace("[controller]", controllerName.ToLower()).TrimEnd('/') ?? controllerName) + "/" + action.Route?.Replace("[action]", action.Name.ToLower())).TrimEnd('/'); List <HttpServiceActionParameterTransferObject> inlineParameters = action.Parameters.Where(x => !x.FromBody && x.Inline).OrderBy(x => x.InlineIndex).ToList(); List <HttpServiceActionParameterTransferObject> urlParameters = action.Parameters.Where(x => !x.FromBody && !x.Inline && x.AppendName).ToList(); List <HttpServiceActionParameterTransferObject> urlDirectParameters = action.Parameters.Where(x => !x.FromBody && !x.Inline && !x.AppendName).ToList(); uri = urlParameters.Count > 0 ? $"{uri}?{urlParameters.First().Name}=" : urlDirectParameters.Count > 0 ? $"{uri}?" : uri; MultilineCodeFragment code = Code.Multiline(); DeclareTemplate declareTemplate = null; bool hasReturnType = returnType.Name != "void"; bool isPrimitive = this.IsPrimitive(returnType); if (returnType.Name == "Array") { TypeTemplate type = ((GenericTypeTemplate)returnType).Types[0]; declareTemplate = Code.Declare(returnType, "list", Code.TypeScript("[]")).Constant(); code.AddLine(declareTemplate) .AddLine(Code.TypeScript("for (const entry of <[]>result)").StartBlock()) .AddLine(Code.Local(declareTemplate).Method("push", isPrimitive ? (ICodeFragment)Code.Cast(type, Code.Local("entry")) : Code.New(type, Code.Local("entry"))).Close()) .AddLine(Code.TypeScript("").EndBlock()); } else if (hasReturnType) { declareTemplate = Code.Declare(returnType, "model", isPrimitive ? (ICodeFragment)Code.Cast(returnType, Code.Local("result")) : Code.New(returnType, Code.Local("result"))).Constant(); code.AddLine(declareTemplate); } code.AddLine(Code.Local("subject").Method("next").WithParameter(declareTemplate.ToLocal()).Close()) .AddLine(Code.Local("subject").Method("complete").Close()); ChainedCodeFragment parameterUrl = Code.This().Field(serviceUrlField); if (inlineParameters.Count == 0) { parameterUrl = parameterUrl.Append(Code.String(uri)); } foreach (HttpServiceActionParameterTransferObject parameter in inlineParameters) { string[] chunks = uri.Split(new [] { $"{{{parameter.Name}}}" }, StringSplitOptions.RemoveEmptyEntries); parameterUrl = parameterUrl.Append(Code.String(chunks[0])).Append(Code.Local(parameter.Name)); uri = chunks.Length == 1 ? string.Empty : chunks[1]; } bool isFirst = true; foreach (HttpServiceActionParameterTransferObject parameter in urlDirectParameters) { if (isFirst) { isFirst = false; parameterUrl = parameterUrl.Append(Code.Local(parameter.Name)); } else { parameterUrl = parameterUrl.Append(Code.String("&")).Append(Code.Local(parameter.Name)); } } foreach (HttpServiceActionParameterTransferObject parameter in urlParameters) { if (isFirst) { isFirst = false; parameterUrl = parameterUrl.Append(Code.Local(mapping[parameter])); } else { parameterUrl = parameterUrl.Append(Code.String($"&{parameter.Name}=")).Append(Code.Local(mapping[parameter])); } } methodTemplate.WithCode( Code.This() .Field(httpField) .Method(action.Type.ToString().ToLowerInvariant(), parameterUrl, action.RequireBodyParameter ? Code.Local(action.Parameters.Single(x => x.FromBody).Name) : null, Code.Local("httpOptions") ) .Method("subscribe", Code.Lambda(hasReturnType ? "result" : null, code), errorCode).Close() ); methodTemplate.WithCode(Code.Return(Code.Local("subject"))); } } }